java多线程设计wait/notify机制 (synchronized与对象锁)

synchronized(obj) {
    while(!condition) {
        obj.wait();
    }
    obj.doSomething();
}

当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A就wait() , 放弃对象锁.

之后在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就可以唤醒线程A：

synchronized(obj) {
condition = true;
obj.notify();
}

需要注意的概念是：

# 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {…} 代码段内。

# 调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {…} 代码段内唤醒A。

# 当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。

# 如果A1,A2,A3都在obj.wait()，则B调用obj.notify()只能唤醒A1,A2,A3中的一个（具体哪一个由JVM决定）。

# obj.notifyAll()则能全部唤醒A1,A2,A3，但是要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1,A2,A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。

# 当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1,A2,A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1,A2,A3中的一个才有机会获得锁继续执行。

比如下述代码，在SubThread中，如果只是notify，而没有wait，那么SubThread仍然持有lock锁，MyThread虽然被唤醒，但是仍然要等待SubThread执行结束。

Java代码

package test.thread;
//2个线程交替打印。线程1打印奇数，线程2打印偶数
public class ThreadTest {
/**
* @param args
*/
public static void main(String[] args) {
String lock = "lock";
MyThread myThread = new MyThread(lock);
Thread t1 = new Thread(myThread);
t1.start();
try {
// 确保线程t1先执行
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
SubThread sub = new SubThread(lock);
Thread t2 = new Thread(sub);
t2.start();
}
}
class MyThread implements Runnable {
String lock;
public MyThread(String lock) {
this.lock = lock;//当前线程获得lock对象的引用
}
public void run() {
int i = 0;
// 使用lock对象作为监视器
synchronized (lock) {//在lock对象上加锁
System.out.println("The first thread.获得锁");
while (i++ < 20) {
try {
// 每次暂停500毫秒是为了更好地看到效果
Thread.sleep(500);
if (i%2==1) {
System.out.println("The first thread.-->" + i);
// 调用lock监视器的wait()方法，通知本线程释放监视器,本线程等待
// 其他也使用lock对象作为监视器的线程唤醒的时候，本线程得以继续运行
System.out.println("The first thread 被阻塞");
lock.wait();
// 下面的wait(long timeout)表示：若等待5秒后还没有别的线程来唤醒的话，则本线程继续执行
// lock.wait(5000);
}else{
System.out.println("The first thread 解锁lock");
lock.notify();
}
//这个线程当是奇数时，打印数字，打印后，此线程wait。当是偶数时，什么都不做，只是激活lock对象
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
class SubThread implements Runnable {
String lock;
public SubThread(String lock) {
this.lock = lock;
}
public void run() {
int i = 1;
// 这个线程也使用lock对象作为监视器
synchronized (lock) {
System.out.println("The second thread.获得锁");
while (i < 20) {
try {
Thread.sleep(500);
if (i%2==0) {
System.out.println("The second thread.-->" + i);
// 调用lock监视器的wait()方法，通知本线程释放监视器,本线程等待
// 其他也使用lock对象作为监视器的线程唤醒的时候，本线程得以继续运行
System.out.println("The second thread 解锁lock");
lock.notify();
System.out.println("The second thread 被阻塞");
lock.wait();
// 下面的wait(long timeout)表示：若等待5秒后还没有别的线程来唤醒的话，则本线程继续执行
// lock.wait(5000);
}else{
System.out.println("The second thread 什么也没干");
//lock.notify();
}
i++;
//这个线程2，当线程1的wait调用时，此线程2激活。当i是偶数时，打印i，打印后，通知lock解锁（此时thread1得锁，干活），并且此线程2被阻塞
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 调用lock对象的notify()方法，唤醒同一对象监视器中调用wait的第一线程
// 或者调用notifyAll()方法，唤醒同一对象监视器中调用wait的所有线程，具有最高优先级的线程首先被唤醒并执行
//lock.notify();
}
}
}