025 Condition条件

一 . 概述

　　在之前我们我们线程之间进行通信使用的是内置锁的wait()方法和notify()实现的,而我们使用了高级锁之后,就可以使用Condition进行条件控制,

　　　　通过精确的控制我们能够完成更简单的线程控制.

---

 二 .Condition的使用

　　下面我们定义三个线程,让他们按照次序进行输出.　

public class ConditionTest {

    public void testA() {
        System.out.println("aaaa");
    }

    public void testB() {
        System.out.println("bbbbb");
    }

    public void testC() {
        System.out.println("ccccc");
    }

    private static Lock lock = new ReentrantLock();
    private static Condition c1 = lock.newCondition();
    private static Condition c2 = lock.newCondition();
    private static Condition c3 = lock.newCondition();
    private static volatile Integer count = new Integer(0);

    public static void main(String[] args) {
        ConditionTest demo = new ConditionTest();
        new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    if (count % 3 == 0) {
                        // 允许进入
                        demo.testA();
                        // 唤醒B线程
                        c2.signal();
                        count++;
                        // 自己睡眠
                        try {
                            c1.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();

        new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    if (count % 3 == 1) {
                        // 允许进入
                        demo.testB();
                        // 唤醒B线程
                        c3.signal();
                        count++;
                        // 自己睡眠
                        try {
                            c2.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();
        new Thread(() -> {
            while (true) {
                lock.lock();
                try {
                    if (count % 3 == 2) {
                        // 允许进入
                        demo.testC();
                        // 唤醒B线程
                        c1.signal();
                        count++;
                        // 自己睡眠
                        try {
                            c3.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();
    }
}

　　我们发现使用Condition和之前使用内置锁没有什么区别.

---

三 总结

　　我们在使用Lock的时候可以使用Condition完成线程之间的通信,通过这中通信的方式可以完成对线程的精确控制.

　　其中await()方法表示释放条件对象,然后该线程进入到等待队列之中,与wait()方法是十分相似的.

　　同时我们可以看到,通过使用条件对象,我们对线程的控制更加简单,使用之前的内置锁就不意见容易的事情.