线程中wait/notify/notifyAll的用法

前言

多线程时，最关注的就是线程同步，线程间的同步一般用锁来实现，常见的锁就是synchronized和lock。用了synchronized，就不得不提到wait/notify/notifyAll。本文介绍这三者是什么东西。

举例说明

首先明确一点，所有的锁都是加在对象上面的。也就是说，只要是加了同步synchronized的代码，每个线程在运行到这的时候，都要去查一下这个对象上的锁有没有被人占用，如果被人占用了，就要等待。等待也分两种，一种是一直等着，一种是先做别的，别人提醒之后再找。

举个生活中的例子做对比。假设有一个屋子，屋子有一个门，门上面有一个锁。屋子同一个时间只能有一个人，这个人在里面干什么没人管。现在有多个人想进到这个屋子里面，每个进去的人都可以锁门。synchronized(object)里面的object就是门上这把锁，synchronized代码的意思是在执行代码之前，看看这把锁是不是锁着的，如果不是锁着的，就进去工作，同时把门锁上。执行完{}代码之后，就相当于从屋子里面出来，同时打开了锁。wait的意思就某个人甲进入了屋子，工作了一会，想临时先出去。所以他把锁打开，出去了，并把屋子让给了别人。那他什么时候回来呢？必须有别人告诉他，也就是notify。notify和notifyAll的区别在于notify随机告诉某一个人(注意这个人是wait的)，我不用锁了，你用吧；notifyAll是告诉所有等待这个锁的人。

我们下面用这个例子加代码说明这些用法。

情况1：不锁门，不加锁

如果不锁门，就会有多个人进入到这个屋子，这个屋子就是被撑爆。也就是说，如果代码里面不加synchronize，会有多个进程访问同一个资源，造成不可知的错误。这种情况就不举代码的例子了。

情况2：锁门，不加wait和notify

这种情况下，代码如WaitNotifyDemo3所示：

package com.wardensky.multithread.waitnotify;
/**
 * 这个例子就是加锁了，但没有加wait和notify
 *
 * @author zch
 *
 */
public class WaitNotifyDemo3 {
	/**
	 * 这个对象就是所有线程都用的锁。
	 */
	public static Object obj = new Object();
	public static void main(String[] args) throws InterruptedException {
		Thread0_1 t1 = new Thread0_1("Thread WaterMelon");
		Thread0_2 t2 = new Thread0_2("Thread Apple");
		t2.start();
		Thread.sleep(1);
		t1.start();
		System.out.println("完成");
	}
}
/**
 * 这个线程用来演示阻塞，等这个线程工作完，不会告诉别人。<br/>
 *
 * @author zch <br/>
 *
 */
class Thread3_1 extends Thread {
	String name;
	public Thread3_1(String name) {
		this.name = name;
	}
	@Override
	public void run() {
		try {
			synchronized (WaitNotifyDemo3.obj) {
				for (int i = 1; i < 5; i++) {
					Thread.sleep(1000);
					System.out.println("I'm " + this.name + ". I'm doing something " + i);
				}
			}
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
	}
}
/**
 * 这个类用来表示被阻塞的线程，但这个线程并没有wait，所以他一直轮询这个锁，比较占资源。<br/>
 *
 * @author zch
 *
 */
class Thread3_2 extends Thread {
	String name;
	public Thread3_2(String name) {
		this.name = name;
	}
	@Override
	public void run() {
		System.out.println("I'm " + this.name + " . I'm waiting");
		synchronized (WaitNotifyDemo3.obj) {
			System.out.println(this.name + " Finish wait");
		}
	}
}

输出如下：

I'm Thread Apple . I'm waiting
完成
I'm Thread WaterMelon. I'm doing something 1
I'm Thread WaterMelon. I'm doing something 2
I'm Thread WaterMelon. I'm doing something 3
I'm Thread WaterMelon. I'm doing something 4
I'm Thread WaterMelon.  The object notify
Thread Apple Finish wait

在上面这个例子里面，Apple线程一直在轮询这个锁的状态，等到线程WaterMelon用完之后，马上抢占过来。这种情况下，比较耗资源。

情况3: 加wait和notify

我们在情况2的基础上，让Apple线程增加一个wait，让线程WaterMelon增加一个notify，代码如下：

package com.wardensky.multithread.waitnotify;
public class WaitNotifyDemo0 {
	/**
	 * 这个对象就是所有线程都用的锁。
	 */
	public static Object obj = new Object();
	public static void main(String[] args) throws InterruptedException {
		Thread0_1 t1 = new Thread0_1("Thread WaterMelon");
		Thread0_2 t2 = new Thread0_2("Thread Apple");
		t2.start();
		///这个sleep很重要。
		Thread.sleep(1);
		t1.start();
		System.out.println("完成");
	}
}
/**
 * 这个线程用来演示阻塞，等这个线程工作完，会通过notify方法告诉别人。<br/>
 *
 * @author zch <br/>
 *
 */
class Thread0_1 extends Thread {
	String name;
	public Thread0_1(String name) {
		this.name = name;
	}
	@Override
	public void run() {
		try {
			synchronized (WaitNotifyDemo0.obj) {
				for (int i = 1; i < 5; i++) {
					Thread.sleep(1000);
					System.out.println("I'm " + this.name + ". I'm doing something " + i);
				}
				WaitNotifyDemo0.obj.notify();
				System.out.println("I'm " + this.name + ".  The object notify");
			}
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
	}
}
/**
 * 这个类用来表示被阻塞的线程，进入工作状态后，他可以先把锁还给别人，等别人通知他，他才继续工作。<br/>
 *
 * @author zch
 *
 */
class Thread0_2 extends Thread {
	String name;
	public Thread0_2(String name) {
		this.name = name;
	}
	@Override
	public void run() {
		try {
			System.out.println("I'm " + this.name + " . I'm waiting");
			synchronized (WaitNotifyDemo0.obj) {
				WaitNotifyDemo0.obj.wait();
				System.out.println(this.name + " Finish wait");
			}
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
	}
}

输出：

I'm Thread Apple . I'm waiting
完成
I'm Thread WaterMelon. I'm doing something 1
I'm Thread WaterMelon. I'm doing something 2
I'm Thread WaterMelon. I'm doing something 3
I'm Thread WaterMelon. I'm doing something 4
I'm Thread WaterMelon.  The object notify
Thread Apple Finish wait

在这个例子里面，Thread0_2这个线程在synchronized (WaitNotifyDemo0.obj)之后调用了WaitNotifyDemo0.obj.wait();，意思是 我进入了屋子之后，先离开了，让别人处理，但别人处理之后要记得notify我，不然我就不知道了。

需要注意的是，在这个例子里面，两个线程的启动之间有一个sleep，这个sleep很重要，下面会讲到。

情况4：有多个人wait

如果有多个人wait，则唤醒线程尽量用notifyAll。notify是告诉某一个线程，但具体是哪个线程是随机的。notifyAll就是大家再来竞争。

如果用了没有用notifyAll，也可以wait执行之后调用notify，也就是一个执行完再唤醒另外一个。代码示例如下：

package com.wardensky.multithread.waitnotify;
public class WaitNotifyDemo1 {
	public static Object obj = new Object();
	public static void main(String[] args) {
		Thread1_1 t1 = new Thread1_1();
		Thread1_2 t2 = new Thread1_2("Thread Apple");
		Thread1_2 t3 = new Thread1_2("Thread Orange");
		t2.start();
		t3.start();
		try {
			// 必须sleep一下
			Thread.sleep(1);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		t1.start();
		System.out.println("完成");
	}
}
class Thread1_1 extends Thread {
	@Override
	public void run() {
		try {
			synchronized (WaitNotifyDemo1.obj) {
				for (int i = 1; i < 5; i++) {
					Thread.sleep(1000);
					System.out.println("I'm thread111. I'm doing something " + i);
				}
				// WaitNotifyDemo.obj.notify();
				WaitNotifyDemo1.obj.notifyAll();
				System.out.println("I'm thread111. The object notify");
			}
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
	}
}
class Thread1_2 extends Thread {
	String name;
	public Thread1_2(String name) {
		this.name = name;
	}
	@Override
	public void run() {
		try {
			System.out.println("I'm " + this.name + " . I'm waiting");
			synchronized (WaitNotifyDemo1.obj) {
				WaitNotifyDemo1.obj.wait();
				System.out.println(this.name + " Finish wait");
				// 如果不加这句话，就叫不醒别人了。
				// WaitNotifyDemo.obj.notify();
			}
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
	}
}

输出：

I'm Thread Apple . I'm waiting
I'm Thread Orange . I'm waiting
完成
I'm thread111. I'm doing something 1
I'm thread111. I'm doing something 2
I'm thread111. I'm doing something 3
I'm thread111. I'm doing something 4
I'm thread111. The object notify
Thread Orange Finish wait
Thread Apple Finish wait

情况5：情况2里面的不加sleep

如果情况2里面的例子不加sleep，会出现程序无法执行完的情况。原因是两个线程几乎同时运行，但线程2在同步代码之前有一个输出System.out.println("I'm " + this.name + " . I'm waiting");。这个输出会导致他比线程1晚进入同步代码。线程1notify的时候，线程2还没有等待。等到线程2真正等待的时候，已经没有人来唤醒他了。

再看看源码

前面提到过，wait/notify/notifyAll都是在对象上的。实际上，Object对象上都有这些方法。代码如下：

    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);
    }
    public final void wait() throws InterruptedException {
        wait(0);
    }
    public final native void notify();
    public final native void notifyAll();            

从源码中可以看出notify();和notifyAll();都是native的方法。

wait还有几个重载，可以指定等多久。比如下面的代码：

	@Override
	public void run() {
		System.out.println("I'm " + this.name + " . I'm waiting");
		try {
			synchronized (WaitNotifyDemo5.obj) {
				WaitNotifyDemo5.obj.wait(1000 * 1);
				System.out.println(this.name + " Finish wait");
			}
		} catch (Exception e1) {
			e1.printStackTrace();
		}
	}

这个代码的意思是我等1秒钟，1秒之后就进入抢占式了。当前，1秒之前也可以用notify或者notifyAll叫醒我。

跟Thread.sleep的关系

线程还有一个sleep静态方法,有人会混淆sleep和wait的关系。

还用上面的例子，sleep的意思是这个人还在屋子里面睡觉，门还锁着呢，谁也进不来。wait的意思是我把门打开，出去睡觉，等着别人把我叫醒我再回来。

也就是说，wait会释放锁，sleep不会。wait是锁这个对象的方法，sleep是线程的静态方法。

synchronized

synchronized(obj)一个代码段，意思是下面{} 里面的代码执行的时候，要去检查obj上面的锁有没有被别人占用。

同时还有这样一种写法，这是StringBuffer里面的源码:

    @Override
    public synchronized StringBuffer append(Object obj) {
        toStringCache = null;
        super.append(String.valueOf(obj));
        return this;
    }

这段代码相当于

    @Override
    public  StringBuffer append(Object obj) {
	    synchronized(this) {
	        toStringCache = null;
	        super.append(String.valueOf(obj));
	        return this;
	    }
    }

也就是说加锁的对象是this。

如果是静态方法，那么加锁的对象是obj.class，该类的类对象。

总结

• synchronized是要检查锁的代码，如果有锁不往下执行。
• wait只能在同步（synchronize）环境中被调用
• 进入wait状态的线程能够被notify和notifyAll线程唤醒
• wait通常有条件地执行，线程会一直处于wait状态，直到某个条件变为真
• wait方法在进入wait状态的时候会释放对象的锁
• wait方法是针对一个被同步代码块加锁的对象
• sleep方法和多线程没有直接关系，跟锁也没有关系
• wait释放锁，notify和notifyAll不释放锁