3.等待唤醒机制

最新推荐文章于 2022-12-02 11:25:15 发布

你好啊cbw

最新推荐文章于 2022-12-02 11:25:15 发布

阅读量334

点赞数

分类专栏：多线程文章标签： java

本文链接：https://blog.csdn.net/qq_40454863/article/details/113409273

版权

多线程专栏收录该内容

6 篇文章 1 订阅

订阅专栏

等待唤醒机制

1.线程状态如何转换的

我们不需要去研究这几种状态的实现原理，我们只需要知道在做线程操作中存在这样的状态并且理解，新建与被终止还是很容易理解的，下面就研究一下线程从Runnable(可运行)状态与非运行状态之间转换问题。

当线程被创建并启动以后，它不是一启动就进入执行状态，也不是一直处于执行状态。在线程的生命周期中，有6种线程状态，在Thread类的内部类(嵌套类)中描述了线程的状态。

线程状态的描述

首先NEW(新建)状态就是new Thread()或new Thread子类()创建时，即new出这两个对象(线程)时。
然后RUNNABLE(运行)状态，当new出来多个线程时会一起抢夺CPU的执行权，谁抢到谁就处于运行状态，
而没有抢到的线程则处于BLOCKED(阻塞)状态，线程的阻塞状态和执行状态可以互相转换，这主要取决于是否抢到cpu；
当线程执行完run()方法或者调用stop()方法或者线程产生了异常，线程就会进入TERMINATED(死亡)状态；
若调用Thread.sleep(毫秒)方法或者Object.wait(毫秒)方法时，程序就会进入到TIMED_WAITING休眠(睡眠)状态也称计时等待，当线程睡醒后，若是cpu空闲，则该线程就会抢夺cpu进入运行状态，若cpu正被别的线程使用，则睡醒线程则进入阻塞状态。
当线程中调用Object.wait(不设置时间，空参),线程就会进入WAITING即无限(永久)等待状态，可以使用Object.notify()方法将等待状态的线程唤醒。
睡眠状态和等待状态是有所区别的，前者是自己唤醒的，而后者需调用方法来唤醒，二者称冻结状态。
阻塞状态与睡眠、等待状态有所区别，前者是具有cpu的执行资格，等待cpu空闲时执行，后者放弃cpu的执行资格，cpu空闲也不执行。

2.各线程状态

Timed Waiting(计时等待)

Timed Waiting(计时等待/或睡眠)在API中的描述为：一个正在限时等待另一个线程执行一个(唤醒)动作的线程处于这一状态。
在卖票案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠(暂停执行)，以减慢线程。
其实当我们调用sleep方法之后，当前执行的线程就进入到"休眠状态"，就是所谓的Timed Waiting 计时等待，下面通过一个案例加深对该状态的一个理解

实现一个计数器，计数到100，在每一个数字之间暂停1秒，每隔10个数字输出一个字符串

package Thread.demo14.Timed_Waiting;
public class MyThread extends Thread{
    /**
     * 实现一个计数器，计数到100，在每一个数字之间暂停1秒，每隔10个数字输出一个字符串
     */
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i%10==0){ System.out.println(".............."+i); }
            System.out.println(i);
            //使用Thread类的sleep方法让程序睡眠1秒
            try {
                Thread.sleep(1000);
                System.out.println("线程睡眠1秒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        //Thread类的实现类对象(线程类对象)调用start方法开启线程,这里使用匿名类
        new MyThread().start();
    }
}

通过案例可以发现，sleep方法的使用是很简单的，需要记住以下几点:

1.进入TIMED_WAITING状态的一种常见情形是调用sleep方法，单独的线程也可以调用，不一定非要有协作关系。
2.为了让其它线程有机会执行，可以将Thread.sleep()方法的调用放到线程的run方法之内，这样才能保证该线程执行过程中会睡眠。
3.sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable(可运行)状态。
4.sleep()中指定的时间是线程不会运行的最短时间，因此，sleep方法不能保证该线程睡眠到期后就开始立即执行，睡醒后的线程只有抢夺到cpu后才可以运行。

Timed Waiting线程状态图:

首先新建一个线程之后，该线程获取cpu属于可运行状态,如果调用sleep方法，线程就会进入计时等待状态(睡眠)，当计时结束后线程就会回到可运行状态，当程序结束，线程被终止。

Blocked(锁阻塞)

1.Blocked状态在API中的介绍:一个正在阻塞等待一个监视器锁(锁对象)的现场处于这一状态。
2.之前已经学完同步机制，那么这个状态是非常好理解的。比如，线程A与线程B代码中使用同一锁，如果线程A获取到锁，线程A进入到Runnable状态，那么现场B就进入到Blocked锁阻塞状态。
3.这是由Runnable状态进入Blocked状态，除此，Waiting以及Timed Waiting状态也会在某种情况下进入阻塞状态。

Blocked线程状态图:

首先新建一个线程之后，该线程就属于可运行状态(但没有运行即只有抢夺cpu后才能运行),
若该线程(已抢夺cpu)没有争取到锁对象就会进入到锁阻塞状态(并失去cpu)，当线程获取到锁对象后便从锁阻塞状态回到可运行状态并抢夺cpu。

Waiting(无限等待)

Waiting状态在API中介绍为：一个正在无限等待另一个线程执行一个特别的(唤醒)动作的线程处于这一状态。
之前我们是没有遇到这种状态的，可以通过一个简单的代码来进行简单的了解。
进入无限等待状态的线程会放弃cpu执行权以及锁对象，其它多线程可以执行。

3.等待唤醒案例分析与代码

等待唤醒案例分析：

等待唤醒案例涉及线程之间的通信
对于生产者与消费者，消费者向生产者购买产品，消费者等待生产者生产即线程调用wait()方法进入Waiting状态进行无线等待；
当生产者生产出够量的产品后，调用notify()方法唤醒消费者。
一个线程等待另一个线程唤醒就成了线程之间的通信。

等待唤醒案例:线程之间的通信

创建一个顾客线程(消费者):告知老板要的包子种类和数量，然后调用wait方法，放弃cpu的执行，进入WAITING状态(无限等待)。
创建一个老板线程(生产者):花5秒做包子，然后调用notify方法，唤醒顾客吃包子。

注意:

1.顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行。
2.同步使用的锁对象必须保证唯一。
3.只有锁对象才能调用wait方法和notify方法。

Object类中的wait和notify方法:

void wait():在其它线程调用此对象的notify方法或notifyAll方法前，导致当前线程等待。
void notify():唤醒在此对象监视器上等待的单个线程，并继续执行wait方法之后的代码。

package Thread.demo15.WaitAndNotify;
public class Demo1WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        //创建一个顾客线程(消费者)，设置线程任务，使用匿名内部类方式创建多线程
        new Thread(){
            @Override
            public void run() {
                int a=1;
                //使用死循环，表示有很多人排队买包子
               while(true){
                   //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                   synchronized(obj){
                       System.out.println("告知老板要的包子种类和数量");
                       //锁对象调用wait方法，放弃cpu的执行，进入到WAITING状态(无限等待)
                       try {
                           obj.wait();
                       } catch (InterruptedException e) {
                           e.printStackTrace();
                       }
                       //该线程被唤醒后，继续执行的代码
                       System.out.println("我要开吃了");
                       System.out.println("...................第"+(a++)+"位顾客");
                   }
               }
            }
        }.start();

        //创建一个老板线程(生产者)
        new Thread(){
            @Override
            public void run() {
                //使用死循环，老板一直在做包子
                while(true){
                    //老板花5秒做包子,即直接使用Thread类调用静态方法sleep
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //为保证等待和唤醒的线程同一刻只有一个在执行，需使用同步技术，锁对象唯一
                    synchronized(obj){
                        System.out.println("老板5s后做出包子，唤醒顾客吃包子");
                        //包好包子后，锁对象调用notify方法，唤醒顾客吃包子
                        obj.notify();
                    }
                }
            }
        }.start();
    }
}
/**
 * 对于上述两个线程，无论如何都会先执行消费者线程的，因为启动线程后，
 * 若是生产者线程抢夺到cpu后开始执行run方法，当遇到sleep方法进入
 * 计时等待状态后会失去cpu控制权，而这个时候并没有进入同步范畴，
 * 不需要考虑锁对象，则消费者线程抢夺到生产者丢失的cpu控制权后，
 * 便开始执行run方法，当执行wait方法后(此时处于同步代码块中)，
 * 线程失去cpu和锁对象，而生产者线程睡眠时间到并抢夺cpu继续执行，
 * 当执行到notify后该线程便唤醒消费者线程并继续执行。
 */

4.计时等待案例分析与代码

计时等待线程计时结束后自己唤醒自己

进入到TimedWaiting(计时等待)有两种方式:
- 1.使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入Runnable/Blocked状态
- 2.使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒后进入Runnable/Blocked状态。相当于sleep

package Thread.demo15.WaitAndNotify;
public class Demo2TimedWaitingAndNotify {
    public static void main(String[] args) {
        //创建锁对象，保证唯一
        Object obj = new Object();
        //创建顾客线程(消费者)，使用匿名内部类方式创建多线程
        new Thread(){
            int a=1;
            //重写run方法，设置线程任务，买包子
            @Override
            public void run() {
                //使用死循环，表示有很多人排队买包子
                while(true){
                    //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                    synchronized (obj){
                        System.out.println("告知老板要的包子的数量和种类");
                        //锁对象调用wait方法，放弃cpu执行权，进入WAITING无限等待状态。
                        try {
                            obj.wait(5000);//计时等待5s后再执行，只是单线程，相当于sleep
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("我要开吃了");
                        System.out.println("...................第"+(a++)+"位顾客");
                    }
                }
            }
        }.start();
    }
}
/**
 * 计时等待线程计时结束后自己唤醒自己
 */

5.唤醒案例分析

唤醒线程的方法:

void notify():唤醒在此对象监视器上等待的单个线程
void notifyAll():唤醒在此对象监视器上等待的所有线程。

唤醒多个等待线程

使用notifyAll()导致唤醒多个等待线程，一个生产者对应多个消费者。
上述三个线程无论如何都是消费者线程先执行，就算生产者线程先抢夺cpu, 但由于还未进入同步状态时就已经进入睡眠状态，从而失去CPU。

package Thread.demo15.WaitAndNotify;

public class demo3Notify {
    public static void main(String[] args) {
        //创建锁对象，锁对象唯一
        Object obj = new Object();
        //创建一个顾客线程(消费者)
        new Thread(){
            //重写run方法，设置线程任务
            @Override
            public void run() {
                //一直有顾客等待买包子
                while(true){
                    //保证等待和唤醒的线程只能有一个在执行，需要使用同步技术
                    synchronized(obj){
                        System.out.println("顾客1告知老板要的包子种类和数量");
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后要执行的代码
                        System.out.println("包子已经做好了，顾客1开吃");
                        System.out.println("............");
                    }
                }
            }
        }.start();

        //再创建一个顾客线程(消费者)
        new Thread(){
            //重写run方法，设置线程任务
            @Override
            public void run() {
                //一直有顾客在等待买包子，死循环
                while(true){
                    //为保证等待和唤醒的线程只有一个在执行，需要同步技术
                    synchronized (obj){
                        System.out.println("顾客2告知老板要的包子种类和数量");
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //该线程被唤醒后要执行的程序
                        System.out.println("包子已经做好了，顾客2开吃");
                    }
                }
            }
        }.start();

        //创建一个老板线程(生产者)
        new Thread(){
            //重写run方法，设置形成任务
            @Override
            public void run() {
                //老板一直在做包子，死循环
                while(true){
                    //花5s做包子
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //为保证等待和唤醒的线程只有一个在执行，需要同步技术
                    synchronized (obj){
                        System.out.println("老板5s之后做好包子，告知顾客");
                        //做好包子之后，调用notify方法，唤醒顾客线程，吃包子
                        //obj.notify();//若有多个等待线程，随机唤醒一个
                        obj.notifyAll();//唤醒所有等待线程
                    }
                }
            }
        }.start();
    }
}
/**
 * 使用notifyAll()导致唤醒多个等待线程，一个生产者对应多个消费者。
 * 上述三个线程无论如何都是消费者线程先执行，就算生产者线程先抢夺cpu,
 * 但由于还未进入同步状态时就已经进入睡眠状态，从而失去CPU。
 */

6.线程间通信

6.1.概念

概念:多个线程在处理同一个资源，但是处理的动作(线程的任务)却不相同，此时多个线程间需要通信交流。
比如:线程A用来生产包子，线程B用来吃包子，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A和线程B之间就存在线程通信问题。

6.2.为什么要处理线程通信？

多个线程并发执行时，在默认情况下cpu是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且希望他们有规则的执行，那么多线程之间需要协调通信，以此来完成多线程共同操作一份数据。
比如，不能线程A只顾着吃包子，线程B没有时间生产包子，也不能线程B一直生产包子，顾客没有时间吃包，应该线程A告诉B吃完了，B再去生产，生产完成后再去通知A可以吃了，

6.3.如何保证线程间通信有效利用资源？

多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。
就是多个线程在操作同一份数据时，避免对同一共享变量的争抢，也就是我们需要使用一定的手段使各个线程能有效的利用资源，
这种手段即--等待唤醒机制。

7.等待唤醒机制概述

等待唤醒机制:线程之间的通信。
重点:有效的利用资源(生产一个包子，吃一个包子，再生产一个包子，再吃一个包子，...如此反复进行)

线程通信:对包子状态进行判断

没有包子-消费者唤醒生产者线程-消费者线程等待-生产者线程生产-生产出包子-修改包子的状态为有
有包子-生产者线程唤醒消费者线程-生产者线程等待-消费者线程吃包子-吃完包子-修改包子状态为没有
没有包子-消费者线程唤醒生产者线程-消费者线程等待-生产者线程生产....一直有序的进行沟通

概述:

这是多个线程间的一种协作机制。谈到线程我们经常想到的是线程间的竞争，比如去争夺锁，但这不是全部，线程之间也会有协作机制。就好比在公司里面你和同事之间存在晋升时的竞争，但更多的时候是合作完成任务。
就是在一个线程进行了规定操作后，就进入等待状态(wait())，等待其它线程执行完他们的执行代码过后，再将其唤醒(notify)，在有多个线程在进行等待时，如果需要，可以使用notifyAll()来唤醒所有的等待线程。
wait/notify就是线程间的一种协作机制。

8.等待唤醒机制中方法

等待唤醒机制就是用于解决线程间通信的问题，使用到3个方法的含义如下:

1.wait:线程不再活动，不再参与调度，进入wait set中，因此不会浪费cpu资源，也不会去竞争锁，这时的线程状态即是WAITING无限等待状态。它还要等着别的线程执行一个特别的动作，即是"通知"在这个对象上等待的线程从wait set中释放出来，重新进入到调度队列(ready queue)中。
2.notify:则选取所通知对象(锁对象)的wait set中的一个线程释放；比如餐馆有空位置后，等候最久顾客先入座。
3.notifyAll:释放所通知对象的wait set上所有的线程。

注意:

哪怕只通知了一个等待线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步代码块中，此刻它已经不持有锁，所以它需要再次获取锁(很可能面临其它线程竞争)，成功后在能在当初调用wait方法之后的地方回复执行。

总结如下:

如果能获取锁，线程就从WAITING状态变成RUNNABLE状态。
否则，从wait set出来，又进入entry set,线程就从WAITING状态变成BLOCKED状态。

调用wait和notify方法需要注意的细节:

1.wait方法和notify方法必须由同一个锁对象调用。因为对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。(notify唤醒在此对象监视器上等待的单个线程)。
2.wait和notify方法是属于Object类的方法。因为锁对象可以是任意的对象，而任意的对象所属类都是继承了Object类。
3.wait方法和notify方法必须要在同步代码块或者是同步函数中使用。因为必须要通过锁对象调用这2个方法。

9.等待唤醒机制需求分析与代码

等待唤醒机制需求分析:分析需要哪些类

 * 等待唤醒机制需求分析:分析需要哪些类
     * 1.资源类:包子类
     *         设置包子的属性:皮
     *                       馅
     *                       包子的状态:true/false有/没有
     * 2.生产者类(包子铺):是一个线程类，可以继承Thread
     *         设置线程任务(run):生产包子
     *         对包子的状态进行判断
     *         true:有包子
     *                包子铺调用wait方法进入等待状态
     *         false:没有包子
     *                包子铺生产包子
     *                增加一些趣味性:交替生产两种包子，有两种状态(i%2==0)取模判断
     *                包子铺生产好包子
     *                修改包子的状态位true有
     *                唤醒吃货线程，让吃货线程吃包子
     * 3.注意：
     *        为提高资源利用率，
     *        包子铺线程和吃货线程关系--通信(互斥)关系
     *        因此需要同步技术保证两个线程只能有一个在执行
     *        锁对象必须保证唯一，可以使用包子对象作为锁对象
     *        包子铺类和吃货类就需要把包子对象作为参数传递进来
     *           1.需要在成员位置创建一个包子变量
     *           2.使用带参数构造方法，为这个包子变量赋值
     *
     * 4.消费者类(吃货):是一个线程类，可以继承Thread
     *         设置线程任务(run):吃包子
     *         对包子的状态进行判断
     *         false:没有包子
     *               吃货线程调用wait方法进入等待状态
     *         true:有包子
     *               吃货吃包子
     *               吃完包子
     *               修改包子的状态位false没有
     *               吃货唤醒包子铺线程，生产包子
     * 5.测试类:
     *         包含Main方法，程序执行的入口，启动程序
     *         创建包子对象，创建包子铺线程，开启，创建吃货线程，开启

资源类:包子

package Thread.demo16.WaitAndNotify1;
public class Baozi {
    String pi;
    String xian;
    //包子状态，初始设置为false没有包子
    boolean flag=false;
}

生产类:包子铺

package Thread.demo16.WaitAndNotify1;
public class BaoZiPu extends Thread{ //包子铺线程
    //1.需要在成员位置创建一个包子变量
    private Baozi bz;
    //2.使用带参数构造方法，为这个包子变量赋值
    public BaoZiPu(Baozi bz){
        this.bz=bz;
    }
    //设置线程任务(run):生产包子
    @Override
    public void run() {
        //定义一个变量
        int cout=0;
        //使用死循环，包子铺一直生产包子，
        while(true){
            //需要同步技术保证两个线程只能有一个在执行
            synchronized (bz){
                //对包子状态进行判断
                if (bz.flag==true){
                    //有包子，包子铺调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                //被唤醒后执行，包子铺生产包子
                //增加一些趣味性：交替生产两种包子
                if (cout%2==0){
                    //生产 薄皮三鲜馅包子
                    bz.pi="薄皮";
                    bz.xian="三鲜馅";
                }else{
                    //生产 冰皮 牛肉大葱馅包子
                    bz.pi="冰皮";
                    bz.xian="牛肉大葱馅";
                }
                cout++;
                System.out.println("包子铺正在生产:"+bz.pi+bz.xian+"包子");
                //生产包子需要3s时间
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //包子铺生产好包子，修改包子的状态为true有
                //由于在同步块中，所以线程睡眠只会失去cpu,不会失去锁，
                //其它线程获取cpu后没有锁也无法执行，只能重新交回cpu
                bz.flag=true;
                //唤醒吃货线程，让吃货线程吃包子
                bz.notify();
                System.out.println("包子铺生产好了:"+bz.pi+bz.xian+"包子，可以吃了");
            }
        }
    }
}

消费者类:顾客

package Thread.demo16.WaitAndNotify1;
public class ChiHuo extends Thread{  //吃货线程类
    //1.需要在成员位置创建一个包子变量
    private Baozi bz;
    //2.使用带参数构造方法，为这个包子变量赋值
    public ChiHuo(Baozi bz){
        this.bz=bz;
    }
    //设置线程任务(run):吃包子
    @Override
    public void run() {
        //使用死循环，让吃货一直吃包子
        while(true){
            //必须使用同步技术保证两个线程只能有一个在执行
            synchronized (bz){
                //对包子状态判断
                if (bz.flag==false){
                    //没有包子，锁对象调用wait方法进入等待状态
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //被唤醒之后执行的代码，吃包子
                System.out.println("吃货正在吃:"+bz.pi+bz.xian+"的包子");
                //吃货吃完包子
                //修改包子的状态为false没有
                bz.flag=false;
                //吃货唤醒包子铺线程：生产包子
                bz.notify();
                System.out.println("吃货把:"+bz.pi+bz.xian+"包子吃完，包子铺开始生产包子");
                System.out.println("...................................");
            }
        }
    }
}

测试类

package Thread.demo16.WaitAndNotify1;
public class Test {
    public static void main(String[] args) {  //main方法，程序总入口
        //创建包子对象，并创建包子铺线程和吃货线程，
        //把这个包子对象分别作为参数传递到两个线程中作为锁对象，唯一
        Baozi bz=new Baozi();
        //创建包子铺线程，开启，生产包子
        new BaoZiPu(bz).start();
        //创建吃货线程，开启，吃包子
        new ChiHuo(bz).start();
    }
}