java多线程 -- Condition 控制线程通信

Api文档如此定义：

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

Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了避免兼容性问题，Condition 方法的名称与对应的 Object 版本中的不同。
在 Condition 对象中，与 wait、notify 和 notifyAll 方法对应的分别是await、signal 和 signalAll。
Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得Condition 实例，请使用其 newCondition() 方法。

api相关方法：

1. void await()造成当前线程在接到信号或被中断之前一直处于等待状态。
2. boolean await(long time, TimeUnit unit) 造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
3. long awaitNanos(long nanosTimeout) 造成当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。
4. void awaitUninterruptibly()造成当前线程在接到信号之前一直处于等待状态。
5. boolean awaitUntil(Date deadline)造成当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态。
6. void signal()唤醒一个等待线程。
7. void signalAll()唤醒所有等待线程。

例如：

package com.company;

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

/*
 * 生产者消费者案例：
 */
public class TestProductorAndConsumerForLock {

    public static void main(String[] args) {
        Clerk clerk = new Clerk();

        Productor pro = new Productor(clerk);
        Consumer con = new Consumer(clerk);

        new Thread(pro, "生产者 A").start();
        new Thread(con, "消费者 B").start();

//         new Thread(pro, "生产者 C").start();
//         new Thread(con, "消费者 D").start();
    }

}

class Clerk {
    private int product = 0;

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    // 进货
    public void get() {
        lock.lock();

        try {
            if (product >= 1) { // 为了避免虚假唤醒，应该总是使用在循环中。
                System.out.println("产品已满！");

                try {
                    condition.await();//替代this.wait;
                } catch (InterruptedException e) {
                }

            }
            System.out.println(Thread.currentThread().getName() + " : "
                    + ++product);

            condition.signalAll();//代替this.notifyall();
        } finally {
            lock.unlock();
        }

    }

    // 卖货
    public void sale() {
        lock.lock();

        try {
            if (product <= 0) {
                System.out.println("缺货！");

                try {
                    condition.await();//替代this.wait;
                } catch (InterruptedException e) {
                }
            }

            System.out.println(Thread.currentThread().getName() + " : "
                    + --product);

            condition.signalAll();//代替this.notifyall();

        } finally {
            lock.unlock();
        }
    }
}

// 生产者
class Productor implements Runnable {

    private Clerk clerk;

    public Productor(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            clerk.get();
        }
    }
}

// 消费者
class Consumer implements Runnable {

    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            clerk.sale();
        }
    }

}

结果：

缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0
缺货！
生产者 A : 1
消费者 B : 0