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对象上的锁，从而造成死锁。