引言
在Java中，可以通过配合调用Object对象的wait，notify和notifyAll来实现线程间的通信。
在线程中调用wait方法，将阻塞带带其他线程的通知（其他线程调用notify或notifyAll）。
在线程中调用notify或notifyAll将通知其他线程从wait方法处返回。
Object是所有类的父类，它有5个方法组成了等待/通知机制的核心：notify()，notifyAll()，wait()，wait(long)和wait(long, int)。
在Java中，所有的类都从Object继承而来，因此所有的类都拥有这些共有方法。而且由于他们都被声明为final，因此在子类中不能覆写任何一个方法。
public class Object {
public final native void notify();
public final native void notifyAll();
public final void wait() throws InterruptedException {
wait(0);
}
public final native void wait(long timeout) throws InterruptedException;
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}
if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}
if (nanos > 0) {
timeout++;
}
wait(timeout);
}
}
wait
该方法用来将当前线程置于休眠状态，直到接到通知或被中断，在调用wait方法之前，线程必须要获得该对象级别锁，否则编译可以通过，但是运行会抛出异常IllegalMonitorStateException（它是RuntimeException的一个子类，不需要try-catch结构），即只能在同步方法或同步块中调用wait。进入wait方法后，当前线程阻塞，并立刻释放锁。在从wait返回前，线程与其他线程竞争重新获得锁。
（1）线程必须要获得该对象级别锁
package com.huawei.thread;
public class Test36 {
public static void main(String[] args) throws InterruptedException {
Object obj = new Object();
obj.wait();
}
}运行截图：
wait(long)/wait(long, int)
显然，这两个方法是设置等待超时时间的，后者在超值时间上加上ns，精度也难以达到，因此，该方法很少使用。对于前者，如果在等待线程接到通知或被中断之前，已经超过了指定的毫秒数，则它通过竞争重新获得锁，并从wait（long）返回。另外，需要知道，如果设置了超时时间，当wait（）返回时，我们不能确定它是因为接到了通知还是因为超时而返回的，因为wait（）方法不会返回任何相关的信息。但一般可以通过设置标志位来判断，在notify之前改变标志位的值，在wait（）方法后读取该标志位的值来判断，当然为了保证notify不被遗漏，我们还需要另外一个标志位来循环判断是否调用wait（）方法。
notify
（1）该方法也要在同步方法或同步块中调用，即在调用前，线程也必须获得该对象的对象级别锁，如果调用notify时没有持有适当的锁，也会抛出IllegalMonitorStateException。
实例：调用lock对象的notify方法，但是获取的锁却是obj对象，所以抛出异常。也就是说，要在某个对象上执行wait、notify方法，先必须锁定该对象。
package com.huawei.thread;
public class Test36 {
public static void main(String[] args) throws InterruptedException {
Object obj = new Object();
Object lock = new Object();
synchronized (obj) {
lock.notify();
}
}
}运行截图：
（2）该方法用来通知那些可能等待该对象的对象锁的其他线程。如果有多个线程等待，则线程规划器任意挑选出其中一个wait状态的线程来发出通知，并使它等待获取该对象的对象锁。
package com.huawei.thread;
public class Test36 {
public static void main(String[] args) throws InterruptedException {
Object obj = new Object();
Thread a = new Thread(new A(obj));
Thread b = new Thread(new B(obj));
a.setName("a");
b.setName("b");
a.start();
b.start();
Thread.sleep(2000);
synchronized (obj) {
obj.notify();
}
}
}
class A implements Runnable {
private Object obj;
public A(Object obj) {
this.obj = obj;
}
@Override
public void run() {
synchronized (obj) {
try {
System.out.println(Thread.currentThread().getName() + " is waiting...");
obj.wait();
System.out.println(Thread.currentThread().getName() + " is end...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class B implements Runnable {
private Object obj;
public B(Object obj) {
this.obj = obj;
}
@Override
public void run() {
synchronized (obj) {
try {
System.out.println(Thread.currentThread().getName() + " is waiting...");
obj.wait();
System.out.println(Thread.currentThread().getName() + " is end...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
} 运行截图：（1）首先a和b分别进入wait阻塞（2）2秒之后main线程调用notify通知了一个线程，a被唤醒执行（3）由于notify只能唤醒一个线程，所以b就永久阻塞了
可以看出：当第一个获得了该对象锁的wait线程运行完毕以后，它会释放掉该对象锁，此时如果该对象没有再次使用notify语句，则即便该对象已经空闲，其他wait状态等待的线程由于没有得到该对象的通知，会继续阻塞在wait状态，直到这个对象发出一个notify或notifyAll。这里需要注意：它们等待的是被notify或notifyAll，而不是锁。这与下面的notifyAll（）方法执行后的情况不同。
（3）notify后，当前线程不会马上释放该对象锁，wait所在的线程并不能马上获取该对象锁，要等到notify所在线程退出synchronized代码块后，当前线程才会释放锁，wait所在的线程也才能可以获取该对象锁。
package com.huawei.thread;
import java.util.Date;
public class Test36 {
public static void main(String[] args) throws InterruptedException {
Object obj = new Object();
Thread a = new Thread(new A(obj));
Thread b = new Thread(new B(obj));
a.setName("a");
b.setName("b");
a.start();
b.start();
Thread.sleep(2000);
synchronized (obj) {
obj.notifyAll();
System.out.println(new Date());
Thread.sleep(3000);
}
}
}
class A implements Runnable {
private Object obj;
public A(Object obj) {
this.obj = obj;
}
@Override
public void run() {
synchronized (obj) {
try {
System.out.println(Thread.currentThread().getName() + " is waiting...");
obj.wait();
System.out.println(Thread.currentThread().getName() + " is end at: " + new Date());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class B implements Runnable {
private Object obj;
public B(Object obj) {
this.obj = obj;
}
@Override
public void run() {
synchronized (obj) {
try {
System.out.println(Thread.currentThread().getName() + " is waiting...");
obj.wait();
System.out.println(Thread.currentThread().getName() + " is end at: " + new Date());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
} 运行截图：可以看出主线程notifyAll之后会sleep(3000)，然后才会释放锁，b线程也是在3秒之后才能获取到锁。
在实际编程中，我们应该尽量在线程调用notify/notifyAll后，立即退出临界区释放锁，即不要在notify/notifyAll后面再写一些耗时的代码。
另外：如果一个对象之前没有调用wait方法，那么调用notify方法是没有任何影响的。
notifyAll
notifyAll使所有原来在该对象上wait的线程统统退出wait的状态（即全部被唤醒，不再等待notify或notifyAll，但由于此时还没有获取到该对象锁，因此还不能继续往下执行），变成等待获取该对象上的锁，一旦该对象锁被释放（notifyAll线程退出调用了notifyAll的synchronized代码块的时候），他们就会去竞争。如果其中一个线程获得了该对象锁，它就会继续往下执行，在它退出synchronized代码块，释放锁后，其他的已经被唤醒的线程将会继续竞争获取该锁，一直进行下去，直到所有被唤醒的线程都执行完毕。
wait/notify模式
通常，多线程之间需要协调工作：如果条件不满足，则等待；当条件满足时，等待该条件的线程将被唤醒，在Java中，这个模式的实现依赖wait/notify。
synchronized(obj) {
while(!condition) {
obj.wait();
}
obj.doSomething();
} 当线程A获得obj锁后，发现条件condition不满足，无法继续下一步处理，于是线程A就wait；
另一个线程B中，如果B改改了某些条件，使得线程A的condition条件满足，就可以唤醒线程A：
synchronized(obj) {
condition = true;
obj.notifyAll();
} 为什么条件测试使用while，而不是if？
实例：有两个线程从List中删除数据，而只有一个线程向List中添加数据。初始时，List为空，只有往List中添加了数据之后，才能删除List中的数据。添加数据的线程向List添加完数据后，调用notifyAll()，唤醒了两个删除线程，但是它只添加了一个数据，而现在有两个唤醒的删除线程，这时如果使用if会怎样？
结论：如果用 if 测试List中的数据的个数，则会出现IndexOutofBoundException。越界异常。原因是，List中只有一个数据，第一个删除线程把数据删除后，第二个线程再去执行删除操作时，删除失败，从而抛出 IndexOutofBoundException。
package com.huawei.thread;
import java.util.ArrayList;
import java.util.List;
public class Test37 {
public static List<String> list = new ArrayList<String>();
public static void main(String[] args) throws InterruptedException {
Object lock = new Object();
SubtractThread sub1 = new SubtractThread(lock);
sub1.setName("sub1");
SubtractThread sub2 = new SubtractThread(lock);
sub2.setName("sub2");
sub1.start();
sub2.start();
Thread.sleep(2000);
AddThread adder = new AddThread(lock);
adder.setName("adder");
adder.start();
}
}
class AddThread extends Thread {
private Object lock;
public AddThread(Object lock) {
this.lock = lock;
}
@Override
public void run() {
synchronized (lock) {
Test37.list.add("test");
lock.notifyAll();
}
}
}
class SubtractThread extends Thread {
private Object lock;
public SubtractThread(Object lock) {
this.lock = lock;
}
@Override
public void run() {
try {
synchronized (lock) {
if (Test37.list.isEmpty()) {//将这里的if改成while即可保证不出现越界异常
System.out.println("wait begin thread name: " + Thread.currentThread().getName());
lock.wait();
System.out.println("wait end thread name: " + Thread.currentThread().getName());
}
Test37.list.remove(0);
System.out.println("list size=" + Test37.list.size());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}运行截图：
另外：
（1）如果要把wait和notify放在一起使用的话，必须先调用notify方法，后调用wait。
（2）假设线程A执行wait，线程B执行notify：如果B先执行了notify然后结束，A执行wait阻塞，那此时A将无法被正常唤醒。（当然可以通过interrupt()方法以抛出异常的方式唤醒A）
wait与中断
请参考《多线程-interrupt(),isInterrupted(),interrupted()》
小结
（1）如果线程调用了对象的wait方法，那么线程便会处于该对象的等待池中，等待池中的线程不会去竞争该对象的锁。
（2）当有线程调用了对象的notifyAll方法（唤醒所有wait线程）或notify方法（只随机唤醒一个wait线程），被唤醒的的线程便会进入该对象的锁池中，锁池中的线程会去竞争该对象锁。
（3）优先级高的线程竞争到对象锁的概率大，假若某线程没有竞争到该对象锁，它还会留在锁池中
（4）唯有线程再次调用wait方法，它才会重新回到等待池中。而竞争到对象锁的线程则继续往下执行，直到执行完了synchronized代码块，它会释放掉该对象锁，这时锁池中的线程会继续竞争该对象锁。
参考资料
http://blog.csdn.net/ns_code/article/details/17225469
http://blog.csdn.net/oracle_microsoft/article/details/6863662
http://www.cnblogs.com/hapjin/p/5492645.html
http://www.cnblogs.com/pangyang/articles/5916349.html
