Condition

Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。Lock可以实现互斥，但是不能实现同步，Condition可以实现通信，相当于notify或者notifyAll。Condition 实例实质上被绑定到一个锁上。

package Thread03;

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

public class ConditionCommunication {
    public static void main(String[] args) {
        final Business business = new Business();
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 1; i <= 50; i++) {
                    business.sub(i);
                }
            }
        }).start();
        for (int i = 1; i <= 50; i++) {
            business.main(i);
        }
    }

    static class Business {
        Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        private boolean bShouldSub = true;

        public void sub(int i) {
            lock.lock();
            try {
                while (!bShouldSub) {
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for (int j = 1; j <= 10; j++) {
                    System.out.println("sub thread sequence of " + j
                            + ", loop of " + i);
                }
                bShouldSub = false;
                condition.signal();
            } finally {
                lock.unlock();
            }
        }

        public void main(int i) {
            lock.lock();
            try {
                while (bShouldSub) {
                    try {
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for (int j = 1; j <= 100; j++) {
                    System.out.println("main thread sequence of " + j
                            + ", loop of " + i);
                }
                bShouldSub = true;
                condition.signal();
            } finally {
                lock.unlock();
            }
        }
    }
}

三个线程打印线程1打印两次，线程2打印4次，线程3打印6次，就这样打印50次，

package Thread03;

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();
        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 1; i <= 50; i++) {
                    business.sub1(i);
                }
            }
        }).start();

        new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 1; i <= 50; i++) {
                    business.sub2(i);
                }
            }
        }).start();

        for (int i = 1; i <= 50; i++) {
            business.sub3(i);
        }
    }

    static class Business {
        Lock lock = new ReentrantLock();
        //需要创建3个condition
        Condition condition1 = lock.newCondition();
        Condition condition2 = lock.newCondition();
        Condition condition3 = lock.newCondition();
        private int shouldSub = 1;

        public void sub1(int i) {
            lock.lock();
            try {
                while (shouldSub!=1) {//线程1等待
                    try {
                        condition1.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for (int j = 1; j <= 2; j++) {//线程1执行
                    System.out.println("sub1 thread sequence of " + j
                            + ", loop of " + i);
                }
                shouldSub=2;//执行完，把标志置为2
                condition2.signal();//唤醒线程2
            } finally {
                lock.unlock();//释放锁
            }
        }


        public void sub2(int i) {
            lock.lock();
            try {
                while (shouldSub!=2) {
                    try {
                        condition2.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for (int j = 1; j <= 4; j++) {
                    System.out.println("sub2 thread sequence of " + j
                            + ", loop of " + i);
                }
                shouldSub =3 ;
                condition3.signal();//唤醒线程3
            } finally {
                lock.unlock();
            }
        }

        public void sub3(int i) {
            lock.lock();
            try {
                while (shouldSub!=3) {
                    try {
                        condition3.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                for (int j = 1; j <= 6; j++) {
                    System.out.println("sub3 thread sequence of " + j
                            + ", loop of " + i);
                }
                shouldSub = 1;
                condition1.signal();
            } finally {
                lock.unlock();
            }
        }
    }
}

假定有一个绑定的缓冲区，如果试图在空的缓冲区上执行 take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行 put 操作，则在有空间变得可用之前，线程将一直阻塞。编程实现。

package Thread03;

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

public class BoundedBuffer {
    final Lock lock = new ReentrantLock();
    final Condition notFull = lock.newCondition();//写线程
    final Condition notEmpty = lock.newCondition();//读线程

    final Object[] items = new Object[100];
    int putptr, takeptr, count;

    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length)//缓冲区满
                notFull.await();//写线程等待
            items[putptr] = x;
            if (++putptr == items.length)//当指针为100,需要把指针置0
                putptr = 0;
            ++count;//缓冲区中，数据数目加1
            notEmpty.signal();//缓冲区不为空，唤醒读线程
        } finally {
            lock.unlock();
        }
    }

    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)//缓冲区为空
                notEmpty.await();//读线程等待
            Object x = items[takeptr];
            if (++takeptr == items.length)//假如指针为100,则在从0开始
                takeptr = 0;
            --count;//取走一个，数据数目减1
            notFull.signal();//缓冲区不满,唤醒写线程
            return x;
        } finally {
            lock.unlock();
        }
    }
}