导读目录：
- 传统的线程通信
- 使用Condition控制线程通信
- 使用阻塞队列(BlockingQueue)控制线程通信
线程的调度具有一定的透明性，程序通常无法准确控制线程的轮换执行，但Java也提供了一些机制来保证线程协调运行
1.传统的线程通信
要实现不同线程之间彼此通信，可借助Object类的方法：
public final native void notify();
public final native void notifyAll();
public final native void wait(long timeout) throws InterruptedException; //等待timeout时间后自动苏醒
public final void wait(long timeout, int nanos)throws InterruptedException {...} //等待timeout时间后自动苏醒
public final void wait() throws InterruptedException {}//一直等待
wait()：导致当前线程等待(会释放对同步监视器的锁)，直到其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程。
notify()：唤醒正在此同步监视器上等待的单个线程。如果所有的线程都在此同步监视器上等待，则会唤醒其中一个线程，选择是任意的。
notifyAll()：唤醒在此同步监视器上等待的所有线程，只有当前线程放弃对该同步监视器的锁定，才可以执行被唤醒的线程。
事例
//取钱
public synchronized void draw(double drawAmount) {
try {
// 如果flag为假，表明账户中还没有人存钱进去，取钱方法阻塞
if (!flag) {
wait();
} else {
// 执行取钱
...
flag = false;
// 唤醒其他线程
notifyAll();
}
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
//存钱
public synchronized void deposit(double depositAmount){
try {
// 如果flag为真，表明账户中已有人存钱进去，则存钱方法阻塞
if (flag) {
wait();
} else {
// 执行存款
...
flag = true;
// 唤醒其他线程
notifyAll();
}
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
2.使用Condition控制线程通信
如果不使用synchronized的关键字来保证同步，而使直接使用Lock对象来保证同步，则系统中就不存在隐式的同步监视器，也就不能使用wait(),notify(),notifyAll()方法来通信了
使用Lock来保证同步时，需要借助Condition类来协调通信。Condition可以让那些已经得到Lock对象却无法继续执行的线程释放Lock对象，也可以唤醒其他处于等待状态的线程
Condition实例被绑定在一个Lock对象上，通过Lock对象来获得Condition对象，该类提供了如下三类方法：
void await()
boolean await(long time, TimeUnit unit)
long awaitNanos(long nanosTimeout)
void awaitUninterruptibly()
boolean awaitUntil(Date deadline)
void signal()
void signalAll()
(1)await()：类似于隐式同步监视器的wait()方法，导致当前线程等待
(2)signal()：唤醒在此Lock对象上等待的当个线程。如果有多个线程在该Lock上等待，则会选择唤醒其中一个线程，选择是任意的
(3)signalAll()：唤醒在此Lock对象上等到的所有线程。
事例
//取钱
public void draw(double drawAmount){
// 加锁
lock.lock();
try
{
// 如果flag为假，表明账户中还没有人存钱进去，取钱方法阻塞
if (!flag) {
cond.await();
}
else {
...
flag = false;
// 唤醒其他线程
cond.signalAll();
}
}
catch (InterruptedException ex) {
ex.printStackTrace();
} finally {
// 使用finally块来释放锁
lock.unlock();
}
}
//存钱
public void deposit(double depositAmount) {
lock.lock();
try {
// 如果flag为真，表明账户中已有人存钱进去，则存钱方法阻塞
if (flag) {
cond.await();
}
else {
// 执行存款
...
flag = true;
// 唤醒其他线程
cond.signalAll();
}
} catch (InterruptedException ex) {
ex.printStackTrace();
} finally {
// 使用finally块来释放锁
lock.unlock();
}
}
3.使用阻塞队列(BlockingQueue)控制线程通信
Java5中提供了一个BlockingQueue接口，是Queue的子接口，但它的主要作用是用于线程同步，而非作为容器
BlockingQueue接口有一个特性，即当生产者线程试图向队列中放元素已满时，该线程会被阻塞；当消费者线程试图从队列中取出元素时，如果队列为空，则该线程会被阻塞
BlockingQueue中提供的两个阻塞方法：
(1)put(E e); //队列装满时，会阻塞
(2)take(); //队列为空时，会阻塞
由于BlockingQueue接口也是Queue的子接口，因此也拥有Queue的方法，总结如下
┌───────────────────┬─────────────┬──────────┬──────────┬───────────────────┐
│ │ 抛出异常 │ 返回值 │ 阻塞线程 │指定超时时长 │
├───────────────────┼─────────────┼──────────┼──────────┼───────────────────┤
│队尾插入元素(满时) │ add(e) │ offer(e) │ put(e) │offer(r,time,unit) │
├───────────────────┼─────────────┼──────────┼──────────┼───────────────────┤
│队头删除元素(空时) │ remove() │ poll() │ take() │poll(time, unit) │
├───────────────────┼─────────────┼──────────┼──────────┼───────────────────┤
│获取不删除(空时) │ element() │ peek() │ 无 │无 │
└───────────────────┴─────────────┴──────────┴──────────┴───────────────────┘
BlockingQueue接口的实现类：
ArrayBlockingQueue: 基于数组实现
LinkedBlockingQueue: 基于链表实现
PriorityBlockingQueue:不是标准的阻塞队列。与前面集合中讲的PriorityQueue类似，取出队列中的最小的元素
SynchronousQueue: 同步队列，对该队列的存、取操作必须交替执行
DelayQueue: 它是一个特殊的BlockingQueue,底层是基于PriorityBlockingQueue实现的
例子：
//生产者
class Producer extends Thread {
...
public void run() {
...
for (int i = 0 ; i < 999999999 ; i++ ) {
System.out.println(getName() + "生产者准备生产集合元素！");
try {
Thread.sleep(200);
// 尝试放入元素，如果队列已满，线程被阻塞
bq.put(strArr[i % 3]);
}
...
}
}
}
// 消费者
class Consumer extends Thread {
...
public void run() {
while(true) {
...
try {
Thread.sleep(200);
// 尝试取出元素，如果队列已空，线程被阻塞
bq.take();
}
...
}
}
}
public class BlockingQueueTest2 {
public static void main(String[] args) {
// 创建一个容量为1的BlockingQueue
BlockingQueue bq = new ArrayBlockingQueue<>(1);
// 启动3条生产者线程
new Producer(bq).start();
new Producer(bq).start();
new Producer(bq).start();
// 启动一条消费者线程
new Consumer(bq).start();
}
}