Java多线程学习（四）等待/通知（wait/notify）机制

其他 2019-04-28 15:20:53 阅读次数: 0

本节思维导图：
在这里插入图片描述

一 等待/通知机制介绍

1.1 不使用等待/通知机制

当两个线程之间存在生产和消费者关系 ，也就是说第一个线程（生产者）做相应的操作然后第二个线程（消费者）感知到了变化又进行相应的操作 。比如像下面的whie语句一样，假设这个value值就是第一个线程操作的结果，doSomething()是第二个线程要做的事，当满足条件value=desire后才执行doSomething()。

但是这里有个问题就是：第二个语句不停过通过轮询机制来检测判断条件是否成立。如果轮询时间的间隔太小会浪费CPU资源，轮询时间的间隔太大，就可能取不到自己想要的数据。所以这里就需要我们今天讲到的等待/通知（wait/notify）机制来解决这两个矛盾。 

while(value=desire){
  doSomething();
}

1.2 什么是等待/通知机制？

通俗来讲：

等待/通知机制在我们生活中比比皆是，一个形象的例子就是厨师和服务员之间就存在等待/通知机制。

  1. 厨师做完一道菜的时间是不确定的，所以菜到服务员手中的时间是不确定的；
  2. 服务员就需要去“等待（wait）”；
  3. 厨师把菜做完之后，按一下铃，这里的按铃就是“通知（nofity）”；
  4. 服务员听到铃声之后就知道菜做好了，他可以去端菜了。

用专业术语讲：

等待/通知机制，是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B调用了对象O的wait()notify()/notifyAll()方法，线程A收到通知后退出wait()等待队列，进入可运行状态，进而执行后续操作。上诉两个线程通过对象O来完成交互，而对象上的wait()方法和notify()/notifyAll()方法的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

1.3 等待/通知机制的相关方法

方法名称 描述
notify() 随机唤醒等待队列中等待同一共享资源的 “一个线程”，并使该线程退出等待队列，进入可运行状态，也就是notify()方法仅通知“一个线程”
notifyAll() 使所有正在等待队列中等待同一共享资源的 “全部线程” 退出等待队列，进入可运行状态。此时，优先级最高的那个线程最先执行，但也有可能是随机执行，这取决于JVM虚拟机的实现
wait() 使调用该方法的线程释放共享资源锁，然后从运行状态退出，进入等待队列，直到被再次唤醒
wait(long) 超时等待一段时间，这里的参数时间是毫秒，也就是等待长达n毫秒，如果没有通知就超时返回
wait(long，int) 对于超时时间更细力度的控制，可以达到纳秒

二 等待/通知机制的实现

2.1 我的第一个等待/通知机制程序

MyList.java

public class MyList  {

    private static List<String> list = new ArrayList<String>();

    public static void add(){
        list.add("this is a String");
    }

    public static int size() {
        return list.size();
    }
}

ThreadA.java

public class ThreadA extends Thread {
    private  Object lock;

    public ThreadA(){}
    public ThreadA(Object lock){
        this.lock = lock;
    }

    @Override
    public void run(){
        try {
            synchronized (lock) {
                if (MyList.size() != 5) {
                    System.out.println("程序运行进入ThreadA线程，打印出了“等待开始！”" + System.currentTimeMillis());
                    System.out.println("ThreadA调用wait方法进入了等待状态");
                    lock.wait();

                    System.out.println("\nThreadA：“ThreadB的事情做完了，它释放了锁，我的等待结束了！” " + System.currentTimeMillis());
                    System.out.println("ThreadA：“我要开始干我的事情了....... ”");
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

ThreadB.java

public class ThreadB extends Thread {
    private  Object lock;

    public ThreadB(){}
    public ThreadB(Object lock){
        this.lock = lock;
    }

    @Override
    public void run(){
        try {
            synchronized (lock) {
                System.out.println("\nThreadB开始执行添加" + System.currentTimeMillis());
                for (int i = 0; i < 10; i++) {
                    MyList.add();
                    if (MyList.size() == 5) {
                        lock.notify();
                        System.out.println("ThreadB：“满足条件了，我已运行notify()发出通知，但是这个时候还不会释放锁，还要做完事情才行！”");
                    }
                    System.out.println("ThreadB添加了" + (i + 1) + "个元素!");
                    Thread.sleep(1000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

Run.java

public class Run {

    /**
     * 程序运行进入ThreadA线程，打印出了“等待开始！”，
     * 随后线程ThreadA调用wait方法进入了等待状态，这个时候ThreadB开始执行，
     * 满足条件之后调用notify()方法，这个时候ThreadA收到通知之后退出等待，
     * 进入了执行状态，然后打印出了“等待结束！”
     * @param args
     */
    public static void main(String[] args){
        try {
            Object lock = new Object();

            ThreadA a = new ThreadA(lock);
            a.start();

            Thread.sleep(50);

            ThreadB b = new ThreadB(lock);
            b.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：
在这里插入图片描述

从运行结果:ThreadA：“ThreadB的事情做完了，它释放了锁，我的等待结束了！” 1555818965533最后输出可以看出，notify()执行后并不会立即释放锁。下面我们会补充介绍这个知识点。

synchronized关键字可以将任何一个Object对象作为同步对象来看待，而Java为每个Object都实现了等待/通知（wait/notify）机制的相关方法，它们必须用在synchronized关键字同步的Object的临界区内。通过调用wait()方法可以使处于临界区内的线程进入等待状态，同时释放被同步对象的锁。而notify()方法可以唤醒一个因调用wait操作而处于阻塞状态中的线程，使其进入就绪状态。被重新唤醒的线程会视图重新获得临界区的控制权也就是锁，并继续执行wait方法之后的代码。如果发出notify操作时没有处于阻塞状态中的线程，那么该命令会被忽略。

如果我们这里不通过等待/通知（wait/notify）机制实现，而是使用如下的while循环实现的话，我们上面也讲过会有很大的弊端。

while(MyList.size() == 5){
	 doSomething();
}

2.2线程的基本状态

上面几章的学习中我们已经掌握了与线程有关的大部分API，这些API可以改变线程对象的状态。如下图所示：
在这里插入图片描述

  1. 新建(new)：新创建了一个线程对象。

  2. 可运行(runnable)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获 取cpu的使用权。

  3. 运行(running)：可运行状态(runnable)的线程获得了cpu时间片（timeslice），执行程序代码。

  4. 阻塞(block)：阻塞状态是指线程因为某种原因放弃了cpu使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有 机会再次获得cpu timeslice转到运行(running)状态。阻塞的情况分三种：

    4.1. 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放 入等待队列(waitting queue)中。
    4.2. 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁 被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。

    4.3. 其他阻塞: 运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

  5. 死亡(dead)：线程run()、main()方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

2.3 notify()锁不释放

当方法wait()被执行后，锁自动被释放，但执行完notify()方法后，锁不会自动释放。必须执行完notify()方法所在的synchronized代码块后才释放。

下面我们通过代码验证一下：
（完整代码：https://github.com/Snailclimb/threadDemo/tree/master/src/wait_notifyHoldLock）

带wait方法的synchronized代码块

synchronized (lock) {
     System.out.println("begin wait() ThreadName="
             + Thread.currentThread().getName());
     lock.wait();
     System.out.println("  end wait() ThreadName="
             + Thread.currentThread().getName());
 }

带notify方法的synchronized代码块

synchronized (lock) {
     System.out.println("begin notify() ThreadName="
             + Thread.currentThread().getName() + " time="
             + System.currentTimeMillis());
     lock.notify();
     Thread.sleep(5000);
     System.out.println("  end notify() ThreadName="
             + Thread.currentThread().getName() + " time="
             + System.currentTimeMillis());
}

如果有三个同一个对象实例的线程a,b,c,a线程执行带wait方法的synchronized代码块然后bb线程执行带notify方法的synchronized代码块紧接着c执行带notify方法的synchronized代码块。

运行效果如下：
在这里插入图片描述
这也验证了我们刚开始的结论：必须执行完notify()方法所在的synchronized代码块后才释放。

2.4 当interrupt方法遇到wait方法

**当线程呈wait状态时，对线程对象调用interrupt方法会出现InterrupedException异常。**

Service.java

public class Service {
    public void testMethod(Object lock) {
        try {
            synchronized (lock) {
                System.out.println("begin wait()");
                lock.wait();
                System.out.println("  end wait()");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("出现异常了，因为呈wait状态的线程被interrupt了！");
        }
    }
}

ThreadA.java

public class ThreadA extends Thread {

    private Object lock;

    public ThreadA(Object lock) {
        super();
        this.lock = lock;
    }

    @Override
    public void run() {
        Service service = new Service();
        service.testMethod(lock);
    }

}

Test.java

public class Test {

    public static void main(String[] args) {

        try {
            Object lock = new Object();

            ThreadA a = new ThreadA(lock);
            a.start();

            Thread.sleep(5000);

            a.interrupt();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

}

运行结果：
在这里插入图片描述

参考：

《Java多线程编程核心技术》

《Java并发编程的艺术》

如果你觉得博主的文章不错，欢迎转发点赞。你能从中学到知识就是我最大的幸运。

作者：SnailClimb在csdn
来源：CSDN
原文：https://blog.csdn.net/qq_34337272/article/details/79690279

猜你喜欢

转载自blog.csdn.net/GeorgeGuoo/article/details/89431961
今日推荐
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
周排行
[编程题]学英语
[codeforces 1288A] Deadline 约数+模
Python的web开发
Docker在Centos 7上的部署
python编码
解决Ubuntu16.04 fatal error: json/json.h: No such file or directory
mysql并发插入
rest接口如何适应jsonp的方案
linux 终端上网设置
高数——等号两边同时求导、积分的解释
每日归档
更多
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022