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

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执行结束。

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();
		}
	}
}