Object类中wait代餐方法和notifyAll方法

package com.yang.Test.ThreadStudy;

import lombok.SneakyThrows;

/**
 * 进入到TimeWaiting(计时等待)有两种方式
 * 1.使用sleep(long m)方法，在毫秒值结束之后，线程睡醒进入到Runnable/Blocked状态
 * 2.使用wait(long m)方法，wait方法如果在毫秒值结束之后，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态
 * 唤醒的方法
 * void notify()唤醒在此对象监视器上等待的单个线程
 * void notifyAll()唤醒在此对象监视器上等待的所有线程
 */
public class WaitAndNotify {
    public static void main(String[] args) {
        //创建锁对象保证唯一
        Object obj = new Object();
        //创建一个顾客线程(消费者)
        new Thread(){
            @SneakyThrows
            @Override
            public void run() {
                //一直等着吃包子
                while(true){
                    //保证等到和唤醒只能有一个在执行
                    synchronized (obj){
                        System.out.println("顾客1告知拉板要的包子的种类和数量");
                        //调用wait方法，放弃cpu的执行，进入WAIYING状态(无限等待)
                        obj.wait();
                    }
                    //唤醒之后执行的代码
                    System.out.println("包子已经做好了,顾客1开吃！");
                }
            }
        }.start();

        new Thread(){
            @SneakyThrows
            @Override
            public void run() {
                //一直等着吃包子
                while(true){
                    //保证等到和唤醒只能有一个在执行
                    synchronized (obj){
                        System.out.println("顾客2告知拉板要的包子的种类和数量");
                        //调用wait方法，放弃cpu的执行，进入WAIYING状态(无限等待)
                        obj.wait();
                    }
                    //唤醒之后执行的代码
                    System.out.println("包子已经做好了,顾客2开吃！");
                }
            }
        }.start();

        //创建一个老板线程(生产者)
        new Thread(){
            @SneakyThrows
            @Override
            public void run() {
                //一直做
                while(true){
                    //花了5秒做包子
                    Thread.sleep(5000);
                    //保证等到和唤醒只能有一个在执行
                    synchronized (obj){
                        System.out.println("老板5秒钟之后做好包子，告知顾客可以吃包子了");
                        //做好包子之后，调用notify方法，唤醒顾客吃包子
                        obj.notify();

                    }
                }
            }
        }.start();

        new Thread(){
            @SneakyThrows
            @Override
            public void run() {
                //一直做
                while(true){
                    //花了5秒做包子
                    Thread.sleep(5000);
                    //保证等到和唤醒只能有一个在执行
                    synchronized (obj){
                        System.out.println("老板2，5秒钟之后做好包子，告知顾客可以吃包子了");
                        //做好包子之后，调用notify方法，唤醒顾客吃包子
                        obj.notifyAll();

                    }
                }
            }
        }.start();
    }
}

运行结果：

线程间通信

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

为什么要处理线程通信：
多个线程并发执行的时候，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些协调通信，依次来帮我们达到多线程共同操作一份数据

标签：obj,notifyAll,void,Object,间通信,线程,唤醒,包子,wait
来源： https://www.cnblogs.com/ailhy/p/16457982.html