Java线程：Condition

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。

条件（也称为条件队列 或条件变量）为线程提供了一个含义，以便在某个状态条件现在可能为 true 的另一个线程通知它之前，一直挂起该线程（即让其“等待”）。因为访问此共享状态信息发生在不同的线程中，所以它必须受保护，因此要将某种形式的锁与该条件相关联。等待提供一个条件的主要属性是：以原子方式 释放相关的锁，并挂起当前线程，就像 Object.wait 做的那样。

Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得 Condition 实例，请使用其 newCondition() 方法。

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;



public class ThreeConditionCommunication {



    public static void main(String[] args) {



        final Business business = new Business();

        final int cycle = 5;

        

        new Thread(new Runnable() {

            @Override

            public void run() {

                for (int i = 1; i <= cycle; i++) {

                    business.sub2(i);

                }

            }

        }).start();



        new Thread(new Runnable() {

            @Override

            public void run() {

                for (int i = 1; i <= cycle; i++) {

                    business.sub3(i);

                }

            }

        }).start();



        for (int i = 1; i <= cycle; i++) {

            business.main(i);

        }

        

    }



    static class Business {

        Lock lock = new ReentrantLock();

        Condition condition1 = lock.newCondition();

        Condition condition2 = lock.newCondition();

        Condition condition3 = lock.newCondition();

        private volatile int shouldSub = 1;



        public void sub2(int i) {

            lock.lock();

            try {

                while (shouldSub != 2) {

                    try {

                        condition2.await();

                    }

                    catch (Exception e) {

                        e.printStackTrace();

                    }

                }

                for (int j = 1; j <= 10; j++) {

                    System.out.println("sub2 thread sequence of " + j + ",loop of " + i);

                }

                shouldSub = 3;

                condition3.signal();

            }

            finally {

                lock.unlock();

            }

        }



        public void sub3(int i) {

            lock.lock();

            try {

                while (shouldSub != 3) {

                    try {

                        condition3.await();

                    }

                    catch (Exception e) {

                        e.printStackTrace();

                    }

                }

                for (int j = 1; j <= 20; j++) {

                    System.out.println("sub3 thread sequence of " + j + ",loop of " + i);

                }

                shouldSub = 1;

                condition1.signal();

            }

            finally {

                lock.unlock();

            }

        }



        public void main(int i) {

            lock.lock();

            try {

                while (shouldSub != 1) {

                    try {

                        condition1.await();

                    }

                    catch (Exception e) {

                        e.printStackTrace();

                    }

                }

                for (int j = 1; j <= 5; j++) {

                    System.out.println("main thread sequence of " + j + ",loop of " + i);

                }

                shouldSub = 2;

                condition2.signal();

            }

            finally {

                lock.unlock();

            }

        }



    }

}