线程间通知和唤醒:

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用法比较

Java类的生命周期详解

JVM优点与缺点的深入分析

Windows消息机制VC

Spring 定时任务的几种实现

MySQL 主从复制原理以及架构

阻塞和非阻塞通信

select,poll,epoll区别

Linux中select poll epoll的区别

epoll 两种触发模式

5种服务器网络编程模型讲解

Servlet 工作原理解析

Tomcat 系统架构与设计模式:工作原理

Kafka:下一代分布式消息系统

Zookeeper 工作原理

PHP 异步后台处理

Redis 核心知识图谱

Nginx 架构模型深入分析

Nginx 设计原理与技术架构

VC++中四种进程或线程同步互斥的控制方法

pthread多线程编程的学习小结

Python 多线程解析

Python 线程池简单实现

Python学习入门(21)——线程