多线程Condition用法

柔情只为你懂 2022-05-23 13:48 176阅读 0赞

**深知身在情长在，怅望江头江水声**  
此前，我们知道用synchronized与wait()和notify()/notifyAll()方法结合可以实现等待/通知模式。但是，在使用notify()/notifyAll()方法进行通知时，被通知的线程却是由JVM随机选择的。为了摆脱这种窘境，Java在1.5引入了ReentrantLock和Condition类结合使用来达到有选择性的进行线程通知，在调度线程上更加灵活。下面是个测试方法：

运行结果如下：  
![这里写图片描述][70]  
如图，成功的实现了等待/通知模式  
**Object类中的wait()方法相当于Condition类中await()方法。**  
**Object类中的wait(long time)方法相当于Condition类中await(long time,TimeUnit unit)方法。**  
**Object类中的notify()方法相当于Condition类中signal()方法。**  
**Object类中的notifyAll()方法相当于Condition类中signalAll()方法。**

修改上面代码，测试实现部分通知：

import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    
    public class Test {
        private Lock lock = new ReentrantLock();
        public Condition conditionB = lock.newCondition();
        public Condition conditionA = lock.newCondition();
        //等待
        public void awaitA() {
            try {
                lock.lock();    //调用lock.lock()方法的线程就持有了"对象监视器"，其他线程只有等待锁被释放时再次争抢
                System.out.println("awaitA()时间为：" + System.currentTimeMillis());
                conditionA.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
         }
         //等待
        public void awaitB() {
            try {
                lock.lock();    //调用lock.lock()方法的线程就持有了"对象监视器"，其他线程只有等待锁被释放时再次争抢
                System.out.println("awaitB()时间为：" + System.currentTimeMillis());
                conditionB.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
         }
         //通知
         public void signalA() {
            try {
                lock.lock();
                System.out.println("signalA()时间为：" + System.currentTimeMillis());
                conditionA.signalAll();
            } finally {
                lock.unlock();
            }
         }
         //通知
         public void signalB() {
            try {
                lock.lock();
                System.out.println("signalB()时间为：" + System.currentTimeMillis());
                conditionB.signalAll();
            } finally {
                lock.unlock();
            }
         }
    }
    
    //线程类
    class ThreadA extends Thread {
        private Test test;
        public ThreadA(Test test) {
            super();
            this.test = test;
        }
        @Override
        public void run() {
            test.awaitA();
        }
    }
    
    //线程类
    class ThreadB extends Thread {
        private Test test;
        public ThreadB(Test test) {
            super();
            this.test = test;
        }
        @Override
        public void run() {
            test.awaitB();
        }
    }
    
    //运行主类
    class Run {
        public static void main(String[] args) throws InterruptedException {
            Test test = new Test();
            ThreadA a = new ThreadA(test);
            a.start();
            ThreadB b = new ThreadB(test);
            b.start();
            Thread.sleep(3000);
            test.signalA(); //唤醒A
        }
    }

实验结果：  
![这里写图片描述][70 1]  
由图可以看出，只有A被唤醒了。所以实现了部分唤醒的功能。

通过此实验可以得知，使用ReentrantLock对象可以唤醒指定种类的线程，这是控制部分线程行为的方便方式。

[70]: /images/20220523/f27d77462b0c42c8b710538d94b849bd.png
[70 1]: /images/20220523/7f233d264acf48f5b0d6c7a3e5207ad5.png