Java 实现线程间通知和唤醒
线程间通知和唤醒：
Condition是个接口，基本的方法就是 await() 和 signal() 方法；
Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
调用Condition的await()和signal()方法，都必须在lock保护之内，
就是说必须在lock.lock()和lock.unlock之间才可以使用：
Conditon中的await()对应Object的wait()；
Condition中的signal()对应Object的notify()；
Condition中的signalAll()对应Object的notifyAll()
Thread中的sleep()用来实现线程的执行控制。
wait()、notify()、notifyAll() 是 Object类 中的方法
从这三个方法的文字描述可以知道以下几点信息：
1）wait()、notify()和notifyAll()方法是本地方法，并且为final方法，无法被重写。
2）调用某个对象的wait()方法能让当前线程阻塞，并且当前线程必须拥有此对象的monitor（即锁）
3）调用某个对象的notify()方法能够唤醒一个正在等待这个对象的monitor的线程，如果有多个线程都在等待这个对象的monitor，则只能唤醒其中一个线程；
4）调用notifyAll()方法能够唤醒所有正在等待这个对象的monitor的线程；
有朋友可能会有疑问：为何这三个不是Thread类声明中的方法，而是Object类中声明的方法
当然由于Thread类继承了Object类，所以Thread也可以调用者三个方法？
其实这个问题很简单，由于每个对象都拥有monitor（即锁），所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作了，而不是用当前线程来操作，因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。
上面已经提到，如果调用某个对象的wait()方法，当前线程必须拥有这个对象monitor（即锁），因此调用wait()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。
调用某个对象的wait()方法，相当于让当前线程交出此对象的monitor，然后进入等待态，等待后续再次获得此对象的锁（注：Thread类中的sleep方法使当前线程暂停执行一段时间，从而让其他线程有机会继续执行，但它并不释放对象锁）；
notify() 方法能够唤醒一个正在等待该对象的monitor的线程，当有多个线程都在等待该对象的monitor的话，则只能唤醒其中一个线程，具体唤醒哪个线程则不得而知。
同样地，调用某个对象的notify()方法，当前线程也必须拥有这个对象的monitor，因此调用notify()方法必须在同步块或者同步方法中进行（synchronized块或者synchronized方法）。
nofityAll() 方法能够唤醒所有正在等待该对象的monitor的线程，这一点与notify()方法是不同的。
Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition1的await()、signal()这种方式实现线程间协作更加安全和高效。
因此通常来说比较推荐使用Condition，在阻塞队列那一篇博文中就讲述到了，阻塞队列实际上是使用了Condition来模拟线程间协作。
Condition是个接口，基本的方法就是await()和signal()方法；
Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition()
调用Condition的await()和signal()方法，都必须在lock保护之内，
就是说必须在lock.lock()和lock.unlock之间才可以使用
Conditon中的await()对应Object的wait()；
Condition中的signal()对应Object的notify()；
Condition中的signalAll()对应Object的notifyAll()
通知和唤醒示例
等待/通知机制，是指一个线程A调用了对象Object的 wait() 方法进入等待状态，而另一个线程B调用了对象Object的 notify() 或者 notifyAll() 方法，线程A收到通知后从对象Object的wait()方法返回，进而执行后续操作。
上述两个线程通过对象Object来完成交互，而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。
wait 与 sleep 区别
|
|
wait |
sleep |
|
归属类 |
属于Object类（java.lang.Object） |
属于Thread类（java.lang.Thread），静态方法 |
|
释放锁 |
释放了锁，其它线程同步块或方法 |
没有释放锁，不出让系统资源（如cpu） |
|
中断唤醒 |
wait一般不会加时间限制，而是判断是否满足符合条件； 如果符合条件，则notify/notifyall唤醒 |
sleep(milliseconds)后自动唤醒， 如果时间不到可用interrupt()强制中断 |
|
适用范围 |
同步方法或同步块使用（synchronized） |
任何地方都可使用（main、thread线程） |
|
捕获异常 |
必须捕获异常（try/catch） |
不需要捕获异常 |
创建了两个线程——WaitThread和NotifyThread，前者检查flag值是否为false，如果符合要求，进行后续操作，否则在lock上等待，后者在睡眠了一段时间后对lock进行通知，示例如下所示。
代码如下:
public class WaitNotify {
static boolean flag = true;
static Object lock = new Object();
public static void main(String[] args){
Thread waitThread = new Thread(new Wait(),"WaitThread");
waitThread.start();
try{
TimeUnit.SECONDS.sleep(1);
}catch (Exception e){
e.printStackTrace();
}
Thread notifyThread = new Thread(new Notify(),"NotifyThread");
notifyThread.start();
}
static class Wait implements Runnable{
@Override
public void run() {
//加锁，拥有lock的monitor
synchronized (lock){
//当条件不满足时，继续wait,同时释放了lock的锁
while (flag){
try{
System.out.println(Thread.currentThread() + " flag is true. wait @" + new SimpleDateFormat("HH:mm:ss").format(new Date()));
lock.wait();
}catch (InterruptedException e){
e.printStackTrace();
}
}
//条件满足时，完成工作
System.out.println(Thread.currentThread() + " flag is false. running @ " + new SimpleDateFormat("HH:mm:ss").format(new Date()));
}
}
}
static class Notify implements Runnable{
@Override
public void run() {
//加锁，拥有lock的monitor
synchronized (lock){
//获取lock的锁，然后进行通知，通知时不会释放lock的锁
//直到当前线程释放了lock的锁，Wait Thread才能从wait方法中返回
System.out.println(Thread.currentThread() + " hold lock. notify @ " +
new SimpleDateFormat("HH:mm:ss").format(new Date()));
lock.notifyAll();
flag = false;
try{
TimeUnit.SECONDS.sleep(5);
}catch (Exception e){
e.printStackTrace();
}
}
//为了明显的看见第3行和第4行输出的顺序互换加入这一段等待
// try{
// TimeUnit.SECONDS.sleep(1);
// }catch (Exception e){
// e.printStackTrace();
// }
//再次加锁
synchronized (lock){
System.out.println(Thread.currentThread() + " hold lock again. sleep @ " +
new SimpleDateFormat("HH:mm:ss").format(new Date()));
try{
TimeUnit.SECONDS.sleep(5);
}catch (Exception e){
e.printStackTrace();
}
}
}
}
}
运行结果：
/** * 运行结果 * Thread[WaitThread,5,main] flag is true. wait @19:37:43 * Thread[NotifyThread,5,main] hold lock. notify @ 19:37:44 * Thread[NotifyThread,5,main] hold lock again. sleep @ 19:37:49 * Thread[WaitThread,5,main] flag is false. running @ 19:37:54 * * 或 * Thread[WaitThread,5,main] flag is true. wait @19:51:03 * Thread[NotifyThread,5,main] hold lock. notify @ 19:51:04 * Thread[WaitThread,5,main] flag is false. running @ 19:51:09 * Thread[NotifyThread,5,main] hold lock again. sleep @ 19:51:09 * * 因为第3行和第4行输出的顺序可能会互换 */
总结
/** 等待/通知的相关方法 方法名称 描述 notify() 通知一个在对象上等待的线程，使其从wait()放大返回，而返回的前提是该线程获取到了对象的锁 notifyAll() 通知所有等待在该对象上的线程 wait() 调用该方法的线程进入WAITINT状态， 只有等待另外线程的通知或被中断才会返回，需要注意，调用wait()之后，会释放对象的锁 wait(long) 超时等待一段时间，这里的参数时间是毫秒，也就是等待长达毫秒，如果没有通知就超时返回 wait(long,int) 对于超时时间更细粒度的控制，可以达到纳秒 上述例子主要说明了调用wait()、notify()以及notifyAll()时需要注意的细节，如下。 1）使用wait()、notify()和notifyAll()时需要先对调用对象加锁。 2）调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。 3）notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。 4）notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。 5）从wait()方法返回的前提是获得了调用对象的锁。 从上述细节中可以看到，等待/通知机制依托于同步机制，其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。 */
参考推荐：
Java同步方式(2)——wait和notify/notifyall
String、StringBuilder、StringBuffer用法比较
ArrayList、LinkedList、Vector、Map用法比较
版权所有: 本文系米扑博客原创、转载、摘录，或修订后发表，最后更新于 2021-02-04 10:12:07
侵权处理: 本个人博客，不盈利，若侵犯了您的作品权，请联系博主删除，莫恶意，索钱财，感谢！
转载注明: Java 实现线程间通知和唤醒 （米扑博客）
大神级核心技术啊