java多线程notify_java 多线程 线程之间的协作 notify()和notifyAll()

使用notify()而不是notifyAll()是一种优化。使用notify()时，在众多等待同一个锁的任务中只有一个会被唤醒，因此如果你希望使用notify()，就必须保证被唤醒的是恰当的任务。另外，为了使用notify()，所有任务必须等待相同的条件，因为如果你有多个任务在等待不同的条件，那么你就不会知道是否唤醒了恰当的任务。如果使用notify()，当条件发生变化时，必须只有一个任务能够从中受益。最后，这些限制对所有可能存在的子类都必须总是起作用。如果这些规则中有任何一条不满足，那么你就必须使用notifyAll()而不是notify()。

import java.util.Timer;

import java.util.TimerTask;

import java.util.concurrent.Executor;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

/**

* 在有关Java的线程机制的讨论中，有一个令人困惑的描述：notify()将唤醒“所有正在等待的任务”。这是否意味着在程序

* 中任何地方，任何处于wait()状态中的任务都将被任何对notifyAll()的调用唤醒呢？在下面的示例中，与Task2相关的

* 代码说明了情况并非如此---事实上，当notifyAll()因某个特定锁而被调用时，只有等待这个锁的任务才会被唤醒。

*

*

* @create @author Henry @date 2016-12-21

*

*/

class Blocker {

private String name;

public Blocker(String name) {

this.name = name;

}

synchronized void waitingCall() {

try {

while (!Thread.interrupted()) {

wait();

System.out.println(Thread.currentThread() + " " + name);

}

} catch (InterruptedException e) {

// OK to exit this way

System.out.println("InterruptedException");

}

}

synchronized void prod() {

notify();

}

synchronized void prodAll() {

notifyAll();

}

}

/**

* Task 有其自己的Blocker对象。

*

* @create @author Henry @date 2016-12-21

*

*/

class Task implements Runnable {

static Blocker blocker = new Blocker("Task");

@Override

public void run() {

blocker.waitingCall();

}

}

/**

* Task2 有其自己的Blocker对象。

*

* @create @author Henry @date 2016-12-21

*

*/

class Task2 implements Runnable {

// A separate Blocker object;

static Blocker blocker = new Blocker("Task2");

@Override

public void run() {

blocker.waitingCall();

}

}

/**

* Task和Task2每个都有其自己的Blocker对象，因此每个Task对象都会在Task.blocker上阻塞，而每个Task2都会在

* Taks2.blocker上阻塞。在main()中，java.util.Timer对象呗设置为每4/10秒执行一次run()方法，而这个run()

* 方法将经由“激励”方法交替地在Task.blocker上调用notify()和notifyAll()。

* 从输出中你可以看到，即使存在Task2.blocker上阻塞的Task2对象，也没有任何在Task.blocker上的notify()或

* notifyAll()调用会导致Task2对象被唤醒。于此类似，在main()的结尾，调用了timer的cancel(),即使计时器被撤销了，

* 前5个任务也依然在运行，并仍旧在它们对Task.blocker.waitingCall()的调用中被阻塞。对Task2.blocker.prodAll()

* 的调用所产生的输出不包括任何在Task.blocker中的锁上等待任务。

* 如果你浏览Blocker中的prod()和prodAll(),就会发现这是有意义的。这些方法是synchronized的，这意味着它们将获取自身

* 的锁，因此当它们调用notify()或notifyAll()时，只在这个锁上调用是符合逻辑的---因此，将只唤醒在等待这个特定锁的任务。

* Blocker.waitingCall()非常简单，以至于在本例中，你只需声明for(;;)而不是while(!Thread.interrupted())就可以到达

* 相同的效果，因为在本例中，由于异常而离开循环和通过检查interrupted()标志离开循环时没有任何区别的---在两种情况下都要

* 执行相同的代码。但是事实上，这个示例选择检查interrupted()，因为存在着两种离开循环的方式。如果在以后的某个时刻，

* 你决定要循环中添加更多的代码，那么如果没有覆盖从这个循环中退出的这两条路径，就会产生引入错误的风险。

*

* @create @author Henry @date 2016-12-21

*

*/

public class NotifyVsNotifyAll {

public static void main(String[] args) throws Exception {

ExecutorService exec = Executors.newCachedThreadPool();

for (int i = 0; i < 5; i++)

exec.execute(new Task());

exec.execute(new Task2());

Timer timer = new Timer();

timer.scheduleAtFixedRate(new TimerTask() {

boolean prod = true;

@Override

public void run() {

if (prod) {

System.out.println("\nnotify()");

Task.blocker.prod();

prod = false;

} else {

System.out.println("\nnotifyAll()");

Task.blocker.prodAll();

prod = true;

}

}

}, 400, 400);// Run every .4 second

TimeUnit.SECONDS.sleep(5);

timer.cancel();

System.out.println("\n Timer canceled");

TimeUnit.MILLISECONDS.sleep(500);

System.out.println("Task2.blocker.prodAll()");

Task2.blocker.prodAll();

TimeUnit.MILLISECONDS.sleep(500);

System.out.println("\n Shutting down");

exec.shutdownNow();

}

}