java线程wait、notify、notifyAll

    wait()、notify()和notifyAll()是Object类的三个本地方法，且都是final，不能被重写，也就是所有的对象均含有这三个方法。大体上来说，wait()方法是使调用该方法的线程释放对此对象的锁，并使得当前的线程阻塞。notify()方法则是随机选择一个因调用了wait()方法而阻塞的线程解除阻塞。notifyAll()方法则是唤醒所有因调用了wait()方法而阻塞的线程，但是只有一个线程能够获得线程锁。

    注意：这里面涉及的线程操作的均是同一个对象，否则就没有意义了。

    （1）wait()

    1、调用该方法时，当前线程必须拥有对象的锁。

    2、当前线程释放锁，并且进行阻塞。

    3、当前线程会一直被阻塞，除非该线程重新获得对象锁并恢复执行。要使当前线程恢复执行的话，需要另外某个线程调用notify()或notifyAll()方法通知等待该对象锁的线程恢复执行（不一定是当前线程会恢复）。

    4、该方法总是在循环中使用。

synchronized (obj) {
         while (<condition does not hold>)
             obj.wait();
         ... // Perform action appropriate to condition
     }

    5、该方法应该被拥有对象锁的线程调用，否则被抛出异常。

    （2）notify()
    1、唤醒正在等待当前对象锁的某个线程。如果有多个线程均在等待当前对象锁，仅有一个线程会被唤醒。

    2、被唤醒的线程不会立即执行，直到当前线程释放该对象的锁。

    3、该方法应该被拥有对象锁的线程调用，否则被抛出异常。

    （3）notifyAll()

    1、唤醒正在等待当前对象锁的所有线程，这点是和notify()不一样的。

    2、被唤醒的线程不会立即执行，直到当前线程释放该对象的锁。同时，被唤醒的所有线程会进行公平竞争，获得对象锁并进行执行。

    3、该方法应该被拥有对象锁的线程调用，否则被抛出异常。

    注意：

    1、调用这三个方法的时候，线程必须要拥有对该对象的锁，否则将会抛出IllegalMonitorStateException异常。一般都是在synchronized方法或者块中，线程才会拥有锁。

    2、调用notify()和notifyAll()方法后，被唤醒的线程不会立即被执行，而是要等到拥有该对象锁的线程释放该锁后才会被执行。

    3、notify()和notifyAll()很大的不同是：notify()不管有多少个线程被阻塞，只唤醒一个线程，其他被阻塞的线程不会被唤醒，且只有被唤醒的线程才会执行，其他被阻塞会继续阻塞；而notifyAll()则会唤醒所有被阻塞的线程，且这些线程均会执行（前提是要获得对象的锁）。

    例子如下：

package test.thread;

import java.util.ArrayList;
import java.util.List;

/**
 * 生产者和消费简单模拟
 * 
 */
public class Test {
	public static void main(String[] args) {
		final Bean bean = new Bean();
		new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 50; i++)
					bean.create();
			}
		}).start();
		for (int i = 0; i < 50; i++)
			bean.use();
	}
}

class Bean {
	private List<String> list = new ArrayList<String>();

	/**
	 * 生产
	 * 
	 */
	public synchronized void create() {
		while (list.size() != 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		for (int i = 0; i < 10; i++) {
			System.out.println("Create Bean:" + i);
			list.add("Bean: " + i);
		}
		this.notify();
	}

	/**
	 * 消费
	 * 
	 */
	public synchronized void use() {
		while (list.size() != 10) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		while (list.size() > 0) {
			System.out.println(list.remove(0));
		}

		this.notify();
	}
}

     再举一个容易造死锁的例子，如下：

package test.thread;

import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Stack {

	LinkedList list = new LinkedList();

	public synchronized void push(Object x) {
		synchronized (list) {
			list.addLast(x);
			notify();
		}
	}

	public synchronized Object pop() throws Exception {
		synchronized (list) {
			if (list.isEmpty()) {
				wait();
			}

			return list.removeFirst();
		}
	}

	public static void main(String[] args) {
		final Stack s = new Stack();
		ExecutorService exec = Executors.newCachedThreadPool();
		exec.execute(new Runnable() {
			public void run() {
				try {
					System.out.println(s.pop());
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
		exec.execute(new Runnable() {
			public void run() {
				s.push("test");
			}
		});
		exec.shutdown();
	}

}

    上例中，在调用wait()和notify()方法时，只是释放了Stack对象的锁，但LinkedList对象上的锁可能并没有释放，这样可能会导致程序竞争LinkedList对象上的锁，从而造成死锁。