Java学习与复习笔记--等待唤醒机制

线程状态概述：

NEW：尚未启动的线程处于此状态。
RUNNABLE：在Java虚拟机中执行的线程处于此状态。

BLOCKED：被阻塞等待监视器锁定的线程处于此状态。

WAITING：正在等待另一个线程执行特定动作的线程处于此状态。

TIMED_WAITING:正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。

TERMINATED:已退出的线程处于此状态

等待唤醒案例分析：

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

顾客要买包子，和老板说明买包子的数量和种类

顾客就等着老板做包子（调用了wait方法） Waiting状态 无限等待

二者产生通信，wait（）、notify（）

老板开始做包子，做好包子，告诉（调用notify方法）顾客包子做好了，可以开吃了。

等待唤醒案例代码实现：

/*
* 等待唤醒案例：线程之间的通信
* 创建一个顾客线程（消费者）：告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入到WAITING状态（无限等待）
* 创建一个老板线程（生产者）：花了五秒做包子，做好包子之后，调用notify方法，唤醒顾客吃包子
* 注意：
*   顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
*   同步使用的锁对象必须保证是惟一的
*   只有锁对象才能调用wait和notify方法
*   void wait() ：导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
*   void notify() ：唤醒正在等待对象监视器的单个线程。会继续执行wait方法之后的代码
 *  */
public class Demo01WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象
        Object obj=new Object();
        //创建一个顾客线程（消费者）
        new Thread(){
            @Override
            public void run(){
                //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                synchronized (obj){
                    System.out.println("告知老板要的包子的种类和数量");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //唤醒之后执行的代码
                    System.out.println("包子已经做好了，开吃");
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                //花了五秒做包子
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                synchronized (obj){
                    System.out.println("老板5秒钟之后做好包子，告知顾客可以吃包子了");
                    //唤醒
                    obj.notify();
                }
            }
        }.start();
    }
}

Object类中wait带参方法和notify：

/*
* 进入到TimeWaiting（计时等待）有两种方式：
* 1.使用sleep(long m)方法，在毫秒值结束之后线程睡醒进入到Runnable/Blocked状态
* 2.使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被唤醒，就会自动醒来，睡醒进入到Runnable/Blocked状态
*
* 唤醒的方法：
* void notify() 唤醒在此对象监视器上等待的单个线程
* void notifyAll() 唤醒在此对象监视器上等待的所有线程
* */
public class Demo02WaitAndNotify {
    public static void main(String[] args) {
        Object obj=new Object();
        //创建一个顾客线程（消费者）
        new Thread(){
            @Override
            public void run(){
                //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                synchronized (obj){
                    System.out.println("顾客1告知老板要的包子的种类和数量");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //唤醒之后执行的代码
                    System.out.println("包子已经做好了，顾客1开吃");
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run(){
                //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                synchronized (obj){
                    System.out.println("顾客2告知老板要的包子的种类和数量");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //唤醒之后执行的代码
                    System.out.println("包子已经做好了，顾客2开吃");
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                //花了五秒做包子
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                synchronized (obj){
                    System.out.println("老板5秒钟之后做好包子，告知顾客可以吃包子了");
                    //唤醒
                    //obj.notify();//如果有多个等待线程，随机唤醒一个
                    obj.notifyAll();//唤醒所有等待的线程
                }
            }
        }.start();
    }
}

线程间通信：

概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。

我们希望多线程有规律的执行，多线程需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

多个线程在操作同一份数据是，避免对同一共享变量的争夺。我们需要一定的手段使各个线程能够有效地利用资源。

这种手段是--等待唤醒机制

等待唤醒机制概述：

等待唤醒机制：线程之间的通信

重点：有效地利用资源（生产一个包子，吃一个包子，再生产一个包子，再吃一个包子）

通信：对包子的状态进行判断

没有包子--》吃货线程唤醒包子铺线程--》吃货线程等待--》包子铺线程做包子--》做好包子--》修改包子状态为有包子

有包子--》包子铺线程唤醒吃货线程--》包子铺线程等待--》吃货吃包子--》吃完包子--》修改包子状态为没有

没有包子--》吃货线程唤醒包子铺线程--》吃货线程等待--》包子铺线程做包子--》做好包子--》修改包子状态为有包子

...

等待唤醒机制代码实现-包子类&包：

/*
* 资源类：包子类
* 设置包子的属性
*   皮
*   馅
*   包子的状态：有 true 没有 false
*   */
public class Baozi {
    //皮
    String pi;
    //馅
    String xian;
    //包子的状态：有 true 没有 false
    boolean flag=false;
}
/*
* 注意：包子铺线程和包子线程关系--》通信（互斥）
* 必须同时同步技术保证两个线程只能有一个在执行
* 锁对象必须唯一，可以使用包子对象作为锁对象
* 包子铺和吃货类就需要把包子对象作为参数传递进来
* 1.在成员类中创建一个包子变量
* 2.使用带参数构造方法，为这个包子变量赋值
* */
public class BaoZiPu extends Thread{
    //1.在成员类中创建一个包子变量
    private Baozi bz;
    //2.使用带参数构造方法，为这个包子变量赋值
    public BaoZiPu(Baozi bz){
        this.bz=bz;
    }
    //设置线程任务（run）：生产包子
    @Override
    public void run() {
        int count=0;
        //让包子铺一直生产
        while(true){
            //必须同时同步技术保证两个线程只能有一个在执行
            synchronized (bz){
                //对包子状态进行判断
                if(bz.flag==true){
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //被唤醒之后执行，包子铺生产包子
                //交替生产两种包子
                if(count%2==0){
                    //生产 薄皮三鲜馅包子
                    bz.pi="薄皮";
                    bz.xian="三鲜馅";
                }else{
                    //生产 冰皮牛肉大葱馅
                    bz.pi="冰皮";
                    bz.xian="牛肉大葱馅";
                }
                count++;
                System.out.println("包子铺正在生产"+bz.pi+bz.xian+"包子");
                //生产包子需要三秒钟
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //包子铺生产好包子
                //修改包子状态为true
                bz.flag=true;
                //唤醒吃货线程，让吃货线程吃包子
                bz.notify();
                System.out.println("包子铺已经生产好了："+bz.pi+bz.xian+"包子，吃货可以开始吃了！");
            }
        }
    }
}

等待唤醒机制代码实现-吃货类&测试：

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("-----------------");
            }
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        //创建包子对象；
        Baozi bz=new Baozi();
        //创建包子铺线程，开启，生产包子；
        new BaoZiPu(bz).start();
        //创建吃货线程，开启，吃包子；
        new ChiHuo(bz).start();
    }
}

运行结果：

包子铺正在生产薄皮三鲜馅包子
包子铺已经生产好了：薄皮三鲜馅包子，吃货可以开始吃了！
吃货正在吃：薄皮三鲜馅的包子
吃货正在吃：薄皮三鲜馅的包子,包子铺开始生产包子。
-----------------
包子铺正在生产冰皮牛肉大葱馅包子
包子铺已经生产好了：冰皮牛肉大葱馅包子，吃货可以开始吃了！
吃货正在吃：冰皮牛肉大葱馅的包子
吃货正在吃：冰皮牛肉大葱馅的包子,包子铺开始生产包子。
-----------------
包子铺正在生产薄皮三鲜馅包子
包子铺已经生产好了：薄皮三鲜馅包子，吃货可以开始吃了！
吃货正在吃：薄皮三鲜馅的包子
吃货正在吃：薄皮三鲜馅的包子,包子铺开始生产包子。
-----------------
包子铺正在生产冰皮牛肉大葱馅包子
包子铺已经生产好了：冰皮牛肉大葱馅包子，吃货可以开始吃了！
吃货正在吃：冰皮牛肉大葱馅的包子
吃货正在吃：冰皮牛肉大葱馅的包子,包子铺开始生产包子。
-----------------
包子铺正在生产薄皮三鲜馅包子
包子铺已经生产好了：薄皮三鲜馅包子，吃货可以开始吃了！
吃货正在吃：薄皮三鲜馅的包子
吃货正在吃：薄皮三鲜馅的包子,包子铺开始生产包子。

...