Lock的使用

技术文章 11个月前 完美者
1,843 0

标签:super   监视   getname   异常   obj   except   trace   唤醒   需要   

4.1 使用ReentrantLock

在JKD1.5中,新增加了ReentrantLock类也能达到和synchronized关键字同样的效果,并且在扩展功能上更加强大,如嗅探锁定,多路分支通知等功能,在使用上也比synchronized更加灵活。

package ReentrantLock;
/*
 * lock.lock() 代码的线程持有了“对象监视器”,其他线程只有等待锁被释放时再次争抢
 */
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class t1 {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        MyThreadA a1 = new MyThreadA(service);
        a1.setName("A");
        a1.start();
        
        MyThreadAA a2 = new MyThreadAA(service);
        a2.setName("AA");
        a2.start();
        
        Thread.sleep(100);
        
        MyThreadB a3 = new MyThreadB(service);
        a3.setName("B");
        a3.start();
        
        MyThreadBB a4 = new MyThreadBB(service);
        a4.setName("BB");
        a4.start();
    }
}

class MyService {
    private Lock lock = new ReentrantLock();
    
    public void MethodA() {
        try {
            lock.lock();
            System.out.println("methodA begin ThreadName=" + Thread.currentThread().getName() + 
                    " time=" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("methodA end   ThreadName=" + Thread.currentThread().getName() + 
                    " time=" + System.currentTimeMillis());
        }catch (InterruptedException e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally{    //不管是否发生异常,该代码块都执行
            lock.unlock();
        }
    }
    
    public void MethodB() {
        try {
            lock.lock();
            System.out.println("methodB begin ThreadName=" + Thread.currentThread().getName() + 
                    " time=" + System.currentTimeMillis());
            Thread.sleep(5000);
            System.out.println("methodB end   ThreadName=" + Thread.currentThread().getName() + 
                    " time=" + System.currentTimeMillis());
        }catch (InterruptedException e) {
            // TODO: handle exception
            e.printStackTrace();
        }finally{    //不管是否发生异常,该代码块都执行
            lock.unlock();
        }
    }
}

class MyThreadA extends Thread {
    private MyService service;
    
    public MyThreadA(MyService service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        super.run();
        service.MethodA();
    }
}

class MyThreadAA extends Thread {
    private MyService service;
    
    public MyThreadAA(MyService service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        super.run();
        service.MethodA();
    }
}

class MyThreadB extends Thread {
    private MyService service;
    
    public MyThreadB(MyService service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        super.run();
        service.MethodB();
    }
}

class MyThreadBB extends Thread {
    private MyService service;
    
    public MyThreadBB(MyService service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        super.run();
        service.MethodB();
    }
}

methodA begin ThreadName=A time=1603976169500
methodA end   ThreadName=A time=1603976174512
methodA begin ThreadName=AA time=1603976174512
methodA end   ThreadName=AA time=1603976179521
methodB begin ThreadName=B time=1603976179521
methodB end   ThreadName=B time=1603976184522
methodB begin ThreadName=BB time=1603976184522
methodB end   ThreadName=BB time=1603976189534

此实验说明,调用lock.lock()代码的线程就持有了“对象监视器”,其他线程只有等待锁被释放时再次争抢。

 

4.1.3  使用Condition实现等待/通知

类ReentrantLock也可以实现等待/通知模式,需要借助Condition对象。在一个Lock对象里可以创建多个Condition(即对象监视器)实例,线程对象可以注册在指定的Condition中,从而可以有选择地进行线程通知,在调度线程上更加灵活。对比notify/notifyAll方法,被通知的线程却是由JVM随机选择的。

 

/*
 * lock.lock() 代码的线程持有了“对象监视器”,其他线程只有等待锁被释放时再次争抢
 */


package ReentrantLock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class t1 {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        MyThread a1 = new MyThread(service);
        a1.start();
        
        Thread.sleep(3000);
        service.signal();
    }
}

class MyService {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    
    public void await() {
        try {
            lock.lock();
            System.out.println("waitMethod时间为 " + System.currentTimeMillis());
            condition.await();
        }catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
            System.out.println("锁释放了!");
        }
    }
    
    public void signal() {
        try {
            lock.lock();
            System.out.println("signal时间为" + System.currentTimeMillis());
            condition.signal();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
            System.out.println("我已经唤醒了await()方法,我也该结束了");
        }
    }
}

class MyThread extends Thread {
    private MyService service;
    
    public MyThread(MyService service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        super.run();
        service.await();
    }
}

waitMethod时间为 1603978989457
signal时间为1603978992471
我已经唤醒了await()方法,我也该结束了
锁释放了!

Object类中的wait()相当于Condition类中的await()方法。

Object类中的notify()相当于Condition类中的signal()方法。

/*
 * lock.lock() 代码的线程持有了“对象监视器”,其他线程只有等待锁被释放时再次争抢
 */
package ReentrantLock;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class t1 {
    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        MyThreadA a = new MyThreadA(service);
        a.setName("A");
        a.start();
        
        MyThreadB b = new MyThreadB(service);
        b.setName("B");
        b.start();
        

        Thread.sleep(3000);
        //service.signalAll_A();
        service.signalAll_B();
    }
}

class MyService {
    private Lock lock = new ReentrantLock();
    public Condition conditionA = lock.newCondition();
    public Condition conditionB = lock.newCondition();

    
    public void awaitA() {
        try {
            lock.lock();
            System.out.println("begin awaitA时间为  " + System.currentTimeMillis() + " ThreadName = " + Thread.currentThread().getName());
            conditionA.await();
            //Thread.sleep(1000);
            System.out.println("  end awaitA时间为  " + System.currentTimeMillis() + " ThreadName = " + Thread.currentThread().getName());
            
        }catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    
    public void awaitB() {
        try {
            lock.lock();
            System.out.println("begin awaitB时间为  " + System.currentTimeMillis() + " ThreadName = " + Thread.currentThread().getName());
            conditionB.await();
            //Thread.sleep(1000);
            System.out.println("  end awaitB时间为  " + System.currentTimeMillis() + " ThreadName = " + Thread.currentThread().getName());
            
        }catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    
    public void signalAll_A() {
        try {
            lock.lock();
            System.out.println("   signalAll_A时间为 " + System.currentTimeMillis() +" ThreadName=" + Thread.currentThread().getName());
            conditionA.signalAll();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    
    public void signalAll_B() {
        try {
            lock.lock();
            System.out.println("   signalAll_B时间为 " + System.currentTimeMillis() +" ThreadName=" + Thread.currentThread().getName());
            conditionB.signalAll();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

class MyThreadA extends Thread {
    private MyService service;
    
    public MyThreadA(MyService service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        super.run();
        service.awaitA();
    }
}

class MyThreadB extends Thread {
    private MyService service;
    
    public MyThreadB(MyService service) {
        this.service = service;
    }
    
    @Override
    public void run() {
        super.run();
        service.awaitB();
    }
}

begin awaitA时间为  1603982264116 ThreadName = A
begin awaitB时间为  1603982264116 ThreadName = B
   signalAll_B时间为 1603982267131 ThreadName=main
  end awaitB时间为  1603982267131 ThreadName = B

使用ReentrantLock对象可以唤醒指定种类的线程,可以控制部分线程。

 

Lock的使用

标签:super   监视   getname   异常   obj   except   trace   唤醒   需要   

原文地址:https://www.cnblogs.com/xiazhenbin/p/13899693.html

版权声明:完美者 发表于 2020-10-30 12:53:51。
转载请注明:Lock的使用 | 完美导航

暂无评论

暂无评论...