传统的线程通信
假设现在系统当中有两个线程，这两个进程分别代表了存款者和取钱者。现在假设系统有一个特殊的需求，系统要求存款者和取钱者能够不断的重复存款、取钱的动作，而且要求每当存款者将钱存入指定的账户后，取钱者立即取出这笔钱。不允许存款者连续两次存钱，也不允许取钱者连续两次取钱。
为了实现这种功能就要借助Object类提供的wait()、notify()和notifyAll()三个方法。但是这三个方法必须由同步监视器对象调用，还可以分为以下两种情况：
- 对于使用synchronized修饰的同步方法，因为该类的默认实例（this）就是同步监视器，所以可以在同步方法中直接调用这三个方法。
- 对于使用synchronized修饰的同步代码块，同步监视器是synchronized后括号里的对象，所以必须使用对象调用这三个方法。
关于这三个方法的解释如下：
- wait()：导致当前线程等待，直到其它线程调用该线程的notify()和notifyAll()方法来唤醒该线程。wait()方法有三种形式：无时间参数的wait、带毫秒参数的wait和带毫秒、毫微秒参数的wait()（这两种方法都是等待指定时间后自动苏醒）。带wait方法的当前线程会释放对同步监视器的锁定。
- notify()：唤醒在此同步监视器上等待的单个线程。如果所有线程都在此同步监视器上等待，则会选择唤醒其中一个线程。选择是任意性的。只有当前线程放弃对同步监视器的锁定后（使用wait()方法），才可以指定被唤醒的线程。
- notifyAll()：唤醒在此同步监视器上等待的所有线程。只有当线程放弃对该同步监视器的锁定后，才可以执行被唤醒的线程。
程序中可以通过一个旗标来标识账户中是否有存款，当旗标为false时，表明账户中没有存款，存款线程可以向下执行，当存款者把钱存入账户后，将旗标设为true，并调用notify()或notifyAll()方法来唤醒其它线程；当存款者线程进入线程体，如果旗标为true就调用wait()方法让线程等待。
当旗标为true时，表明账户中已经存入了存款，则取钱者线程可以向下执行。当取钱者将钱从账户中取出时，将旗标设为false，并调用notify()或notifyAll()方法来唤醒其它线程：当取钱者线程进入线程体后，如果旗标为false就调用wait()方法让线程等待。
public class Account {
private String accountNo;
private double balance;
//标识账户中是否有存款的旗标
private boolean flag = false;
public Account() {}
public Account(String accountNo, double balance){
this.accountNo = accountNo;
this.balance = balance;
}
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public synchronized void draw(double drawAmount){
try {
if(!flag){
wait();
}else{
System.out.println(Thread.currentThread().getName() + " Succeeded in drawing, poping money. " + drawAmount);
balance -= drawAmount;
System.out.println("Balance is " + balance);
flag = false;
notifyAll();
}
}catch (Exception e) {
e.printStackTrace();
}
}
public synchronized void deposit(double depositAmount){
try {
if(flag){
wait();
System.out.println(Thread.currentThread().getName() + " Succeeded in depositing, storing money. " + depositAmount);
balance += depositAmount;
System.out.println("Balance is " + balance);
flag = true;
notifyAll();
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public int hashCode(){
return accountNo.hashCode();
}
public boolean equals(Object obj){
if(this == obj)
return true;
if(obj != null && obj.getClass() == Account.class){
Account target = (Account)obj;
return target.getAccountNo().equals(accountNo);
}
return false;
}
}
上面的程序使用了wait()和notifyAll()进行控制，对存款者而言，当程序进入了deposit方法时，如果flag为true，则表明账户中已经有存款了，程序调用wait()方法就会阻塞；否则程序向下执行存款操作，当存款操作完成后，系统将flag设为true，然后调用notifyAll()方法来唤醒其它被阻塞的线程——如果系统中有存款者线程，存款者线程也会被唤醒。
public class DrawThread extends Thread {
private Account account;
private double drawAmount;
public DrawThread(String name, Account account, double drawAmount) {
super(name);
this.account = account;
this.drawAmount = drawAmount;
}
public void run() {
for(int i=0;i<100;i++){
account.draw(drawAmount);
}
}
}
public class DepositThread extends Thread {
private Account account;
private double depositAmount;
public DepositThread(String name, Account account, double depositAmount) {
super(name);
this.account = account;
this.depositAmount = depositAmount;
}
public void run() {
for(int i=0;i<100;i++){
account.deposit(depositAmount);
}
}
}
public class Main {
public static void main(String[] args) {
Account acct = new Account("1234567", 0);
new DrawThread("Drawer", acct, 800).start();
new DepositThread("Deposit1", acct, 800).start();
new DepositThread("Deposit2", acct, 800).start();
new DepositThread("Deposit3", acct, 800).start();
}
}
运行程序可以看到存款者线程和取钱者线程交替执行。每当存款者向账户存入800元之后，取钱者线程立即从账户取走这笔钱。由于该程序是三个存款者线程随机的向账户中存款，只有一个取钱者线程执行取钱的操作。只有当取钱者线程取钱之后存款者才可以存款。反过来也是一样的。
最后该程序进入了阻塞的状态无法继续向下执行。这是因为三个存款者线程总共有300次尝试存款的操作，但一个取钱者线程只有100次尝试取钱的操作，所以程序最后被阻塞。
阻塞并不是死锁，对于这种情况取钱者线程已经执行结束。而存款者线程只是在等待其他线程来取钱而已，并不是在等待其他线程释放同步监视器。
使用Condition控制线程通信
如果程序不使用synchronized关键字来保证同步，而是直接使用Lock对象来保证同步，则系统中不存在隐式的同步监视器，也就不能使用wait()、notify()、notifyAll()等方法进行线程通信了。
当使用Lock对象来保证同步的时候，Java提供了一个Condition类来保证协调，使用Condition可以让那些已经得到Lock对象却无法继续执行的线程释放Lock对象，Condition对象也可以唤醒其他处于等待的线程。
Condition将同步监视器方法分解为截然不同的对象，以便通过将这些对象和Lock对象组合使用，为每个对象提供多个等待集。在这种情况下Lock替代了同步方法和同步代码块，Condition替代了同步监视器的功能。
Condition实例被绑定在一个Lock对象上。要获得特定Lock实例的Condition实例，调用Lock对象的newCondition方法即可。Condition类提供了如下三个方法：
- await()：类似于隐式同步监视器上的wait()方法，导致当前线程等待，直到其它线程调用该Condition的signal()方法来唤醒该线程。该await()方法有更多的变体，如long awaitNanos(long nanosTimeout)、void awaitUninterruptibly()、awaitUntil(Date deadline)等，可以完成更丰富的等待操作。
- signal()：唤醒在此Lock对象上等待的单个线程。如果所有线程都在该Lock对象上等待，则会选择唤醒其中的一个线程。选择是任意性的。只有当前线程放弃对该Lock对象的锁定后（使用await()方法），才可以执行被唤醒的线程。
- signalAll()：唤醒在此Lock对象上等待的所有线程。只有当前线程放弃对该Lock对象的锁定后，才可以执行被唤醒的线程。
public class Account {
//显示定义Lock对象
private final Lock lock = new ReentrantLock();
//获得指定Lock对象对应的Condition
private final Condition cond = lock.newCondition();
private String accountNo;
private double balance;
//标识账户中是否有存款的旗标
private boolean flag = false;
public Account() {}
public Account(String accountNo, double balance){
this.accountNo = accountNo;
this.balance = balance;
}
public String getAccountNo() {
return accountNo;
}
public void setAccountNo(String accountNo) {
this.accountNo = accountNo;
}
public double getBalance() {
return balance;
}
public void draw(double drawAmount){
//加锁
lock.lock();
try {
if(!flag){
cond.await();
}else{
System.out.println(Thread.currentThread().getName() + " Succeeded in drawing, poping money. " + drawAmount);
balance -= drawAmount;
System.out.println("Balance is " + balance);
flag = false;
cond.signalAll();
}
}catch (Exception e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
public void deposit(double depositAmount){
lock.lock();
try {
if(flag){
cond.await();
}else{
System.out.println(Thread.currentThread().getName() + " Succeeded in depositing, storing money. " + depositAmount);
balance += depositAmount;
System.out.println("Balance is " + balance);
flag = true;
cond.signalAll();
}
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
lock.unlock();
}
}
}
由于两个线程属于同一进程，它们可以非常方便的共享数据，因此很少需要使用管道流进行通信。
使用阻塞队列（BlockingQueue）控制线程通信
虽然BlockingQueue也是Queue的子接口，但它的主要用途并不是容器，而是作为线程同步的工具。BlockingQueue具有一个特征：当生产者线程试图向BlockingQueue中放入元素时，如果该队列已满则线程被阻塞；当消费者线程试图从BlockingQueue中取出元素时，如果该队列已空，则该线程被阻塞。
程序的两个线程通过交替向BlockingQueue中放入元素、取出元素，即可很好的控制线程的通信。
BlockingQueue提供了如下两个支持阻塞的方法：
- put(E e)：尝试将E元素放入BlockingQueue中，如果该队列的元素已满，则阻塞该线程。
- take()：尝试从BlockingQueue的头部取出元素，如果该队列的元素已空，则阻塞该线程。
BlockingQueue继承了Queue接口，当然也可以使用Queue接口中的方法。这些方法可以分为如下三组： - 在队列尾部插入元素。包括add(E e)、offer(E e)和put(E e)方法，当该队列已满，这三个方法会分别抛出异常、返回false、阻塞队列。
- 在队列头部删除并返回删除的元素。包括remove()、poll()和take()方法。当该队列已空时，这三个方法会分别抛出异常、返回false、阻塞队列。
- 在队列头部取出但不删除元素。包括element()和peek()方法，当队列已空时，这两个方法分别抛出异常、返回false。
使用BlockingQueue实现线程的通信：
public class Producer extends Thread {
private BlockingQueue<String>bq;
public Producer(BlockingQueue<String>bq) {
this.bq = bq;
}
@Override
public void run() {
String [] strArr = new String[]{
"Java",
"Struts",
"Spring"
};
for(int i=0;i<999999999;i++){
System.out.println(getName() + " Producer is ready to produce set elements. ");
try {
Thread.sleep(200);
bq.put(strArr[i % 3]);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(getName() + " produced " + bq);
}
}
}
public class Consumer extends Thread {
private BlockingQueue<String>bq;
public Consumer(BlockingQueue<String>bq) {
this.bq = bq;
}
@Override
public void run() {
while(true){
System.out.println(getName() + " Consumer is ready to consume set elements. ");
try {
Thread.sleep(200);
bq.take();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(getName() + " consumed. " + bq);
}
}
}
public class Main {
public static void main(String[] args) {
//创建一个容量为1的BlockingQueue
BlockingQueue<String>bq = new ArrayBlockingQueue<String>(1);
//启动三个生产者线程
new Producer(bq).start();
new Producer(bq).start();
new Producer(bq).start();
//启动一个消费者线程
new Consumer(bq).start();
}
}
上面的程序启动了三个生产者线程，一个消费者线程。生产者线程用于向BlockingQueue中放入元素，消费者线程用于从BlockingQueue中取出元素。该程序的BlockingQueue的容量为1.因此三个生产者线程无法连续放入元素，必须等待消费者线程取出一个元素后，三个生产者线程的其中之一才能放入一个元素。
