线程的状态图

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

 代码实现

package demo06;
/*
* 等待唤醒案例：线程之间的通信
*   创建一个顾客线程：消费者   告知老板要的 包子 数量和种类，调用wait方法，放弃CPU的执行进入到WAITING状态
* 床架一个老板线程：花了5秒。调用nitify通知顾客
*
* 注意：顾客和老板线程，必须得使用同步代码块进行包裹，保证等待和唤醒只能有一个在执行
* 同步使用的锁对象，必须保证是唯一的
* 只有锁对象才能调用wait和notify方法
*
* */
public class demo06{
    public static void main(String[] args) {
//     创建一个锁对象
        Object obj=new Object();
//        创建一个顾客线程（消费者）
        new Thread(){
            @Override
            public void run(){
//          保证等待和唤醒的线程只能有一个执行，需要使用同步技术
                synchronized (obj){
                    System.out.println("告知老板要的包子的种类的数量");
//                    调用wait（）方法，放弃cpu执行，进入到WAITING状态（无限等待）
                    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();
                }
//                调用nitify通知顾客
               synchronized (obj){
                    System.out.println("老板5秒之后做好包子，告知顾客，可以吃包子了");
                    obj.notify();
               }
            }
        }.start();
    }
}

加上死循环

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

Object类中的wait方法到时间之后可以自动唤醒

唤醒方法：

1void notify 唤醒单个线程

2void notifyAll 唤醒再此对象监视器上等待的所有线程

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

        }.start();
    }
}

线程的状态图

原文：https://www.cnblogs.com/Damocless/p/11875568.html