wait与notify是java同步机制中重要的组成部分。结合与synchronized关键字使用，可以建立很多优秀的同步模型。
synchronized(this){}等价与public synchronized void method(){.....}
同步分为类级别和对象级别，分别对应着类锁和对象锁。类锁是每个类只有一个，如果static的方法被synchronized关键字修饰，则在这个方法被执行前必须获得类锁；对象锁与类锁类似。
首先，调用一个Object的wait与notify/notifyAll的时候，必须保证调用代码对该Object是同步的，也就是说必须在作用等同于synchronized(obj){......}的内部才能够去调用obj的wait与notify/notifyAll三个方法，否则就会报错：
java.lang.IllegalMonitorStateException: current thread not owner
在调用wait的时候，线程自动释放其占有的对象锁，同时不会去申请对象锁。当线程被唤醒的时候，它才再次获得了去获得对象锁的权利。
所以，notify与notifyAll没有太多的区别，只是notify仅唤醒一个线程并允许它去获得锁，notifyAll是唤醒所有等待这个对象的线程并允许它们去获得对象锁，只要是在synchronied块中的代码，没有对象锁是寸步难行的。其实唤醒一个线程就是重新允许这个线程去获得对象锁并向下运行。
顺便说一下notifyall，虽然是对每个wait的对象都调用一次notify，但是这个还是有顺序的，每个对象都保存这一个等待对象链，调用的顺序就是这个链的顺序。其实启动等待对象链中各个线程的也是一个线程，在具体应用的时候，需要注意一下。
网上找的一个实例：
java">package com.bijian.thread;
public class ThreadAttemper {
public static void main(String[] args) {
ThreadA a = new ThreadA();
a.start();
System.out.println("a is start....");
synchronized (a) {
try {
System.out.println("Waiting for a to complete...");
a.wait();
System.out.println("a completed.Now back to main thread");
} catch (InterruptedException e) {
}
}
System.out.println("Total is :" + a.total);
}
}
class ThreadA extends Thread {
int total;
public void run() {
synchronized (this) {
System.out.println("ThreadA is running..");
for (int i = 0; i < 5; i++) {
total += i;
System.out.println("total is " + total);
}
notify();
}
}
}
运行结果：
a is start.... ThreadA is running.. total is 0 total is 1 total is 3 total is 6 total is 10 Waiting for a to complete...
发现程序在一直在a.wait();处，分析不难发现：ThreadA线程已运行结束，对于线程运行结束的对象，因其不可能再执行notify();从而激活主线程中的wait()方法，故一直停在这，不能往下执行。
修改方法有两个：
1.法一(不推荐）：在ThreadA类的run方法中增加sleep方法，使主方法运行至a.wait();处时，ThreadA类的线程还未运行结束。如下所示：
java">package com.bijian.thread;
public class ThreadAttemper {
public static void main(String[] args) {
ThreadA a = new ThreadA();
a.start();
System.out.println("a is start....");
synchronized (a) {
try {
System.out.println("Waiting for a to complete...");
a.wait();
System.out.println("a completed.Now back to main thread");
} catch (InterruptedException e) {
}
}
System.out.println("Total is :" + a.total);
}
}
class ThreadA extends Thread {
int total;
public void run() {
synchronized (this) {
System.out.println("ThreadA is running..");
for (int i = 0; i < 5; i++) {
try {
this.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
total += i;
System.out.println("total is " + total);
}
notify();
}
}
}
运行结果：
a is start.... Waiting for a to complete... ThreadA is running.. total is 0 total is 1 total is 3 total is 6 total is 10 a completed.Now back to main thread Total is :10
2.法二（推荐）：在main方法的a.wait()方法前增加判断，判断ThreadAA类的线程是否处于活动状态。如下所示：
java">package com.bijian.thread;
public class ThreadAttemper {
public static void main(String[] args) {
ThreadA a = new ThreadA();
a.start();
System.out.println("a is start....");
synchronized (a) {
try {
System.out.println("Waiting for a to complete...");
//测试线程是否处于活动状态
if(a.isAlive()) {
a.wait();
}
System.out.println("a completed.Now back to main thread");
} catch (InterruptedException e) {
}
}
System.out.println("Total is :" + a.total);
}
}
class ThreadA extends Thread {
int total;
public void run() {
synchronized (this) {
System.out.println("ThreadA is running..");
for (int i = 0; i < 5; i++) {
total += i;
System.out.println("total is " + total);
}
notify();
}
}
}
运行结果：
a is start.... Waiting for a to complete... ThreadA is running.. total is 0 total is 1 total is 3 total is 6 total is 10 a completed.Now back to main thread Total is :10
从上面的实例我们不难看到：“main()方法在子线程未执行结束时不会结束”。据此思想，我们可以扩展此实例，解决一些现实问题。如main方法启动多个线程依次做一些事情。
扩展实例如下：
java">package com.bijian.thread;
public class ThreadAttemperA {
public static void main(String[] args) {
ThreadA a = new ThreadA();
a.start();//启动a线程
System.out.println("a is start....");
synchronized (a) {
try {
System.out.println("Waiting for a to complete...");
if(a.isAlive()) {
a.wait();
}
System.out.println("a completed.Now back to main thread");
} catch (InterruptedException e) {
}
}
System.out.println("Total is :" + a.total);
ThreadB b = new ThreadB();
b.start();//启动b线程
System.out.println("b is start....");
synchronized (b) {
try {
System.out.println("Waiting for b to complete...");
if(b.isAlive()) {
b.wait();
}
System.out.println("b completed.Now back to main thread");
} catch (InterruptedException e) {
}
}
System.out.println("Total is :" + b.total);
}
}
class ThreadA extends Thread {
int total;
public void run() {
synchronized (this) {
System.out.println("ThreadA is running..");
for (int i = 0; i < 5; i++) {
total += i;
System.out.println("total is " + total);
}
notify();
}
}
}
class ThreadB extends Thread {
int total;
public void run() {
synchronized (this) {
System.out.println("ThreadB is running..");
for (int i = 0; i < 10; i++) {
total += i;
System.out.println("total is " + total);
}
notify();
}
}
}
运行结果：
a is start.... Waiting for a to complete... ThreadA is running.. total is 0 total is 1 total is 3 total is 6 total is 10 a completed.Now back to main thread Total is :10 b is start.... Waiting for b to complete... ThreadB is running.. total is 0 total is 1 total is 3 total is 6 total is 10 total is 15 total is 21 total is 28 total is 36 total is 45 b completed.Now back to main thread Total is :45
从运行结果来看，虽有多个线程，但必须是第一个线程执行完成，再执行下一个线程，即是串行的。在串行的业务场景下，可以用此方法。
