【线程状态】2021-09-06

最新推荐文章于 2024-10-17 19:11:48 发布

m0_51034260

最新推荐文章于 2024-10-17 19:11:48 发布

阅读量77

点赞数

分类专栏： JAVASE笔记文章标签： java

本文链接：https://blog.csdn.net/m0_51034260/article/details/120127754

版权

JAVASE笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

线程状态

线程状态概述（6种状态）
在这里插入图片描述

Timed Waiting（计时等待）

在这里插入图片描述
线程之间的通信

等待唤醒案例上图所示代码实现（线程之间的通信）

package lwq.day06.WaitAndNotify;

/**
 * @author: LWQ
 * @description  等待唤醒 线程之间的通信
 * @date: 2021/9/6 10:06
 */
/*

等待唤醒 线程之间的通信

创建一个顾客线程（消费者）：告知老板包子的种类和数量 调用wait方法 放弃cpu的值行 进入到waiting状态（无限等待状态）
创建一个老板线程（生产者）： 花了5秒做包子 做好包子之后 调用notify方法唤醒顾客吃包子

注意事项：
      顾客和老板线程必须使用同步代码块来包裹起来 保证等待和唤醒只能有一个在执行
      同步使用的锁对象必须保证是惟一的 只有锁对象才能调用wait和notify方法
      Object类中的方法
      void wait()
          在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
      void notify()
          唤醒在此对象监视器上等待的单个线程。
          会继续执行wait方法之后的代码


 */
public class Demo01WaitAndNotify {

    public static void main(String[] args) {

        //1 创建锁对象保证唯一
        Object object = new Object();

        //2创建一个顾客线程（消费者）
        new Thread(){
            //重写Objects类中的run方法
            @Override
            public void run() {

                //一直等着买包子
                while (true){
                    //保证等待和唤醒的线程只能有一个在执行 使用同步技术（同步代码块）
                    synchronized (object){
                        System.out.println("告知老板包子的种类和数量");
                        //调用wait方法 放弃cpu的值行 进入到waiting状态（无限等待状态）
                        try {
                            object.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子做了 吃吧");
                        System.out.println("========================");
                    }
                }

            }
        }.start();


        //创建一个老板线程（生产者）：
        new Thread(){
            重写Objects类中的run方法
            @Override
            public void run() {

                // 一直做包子
                while (true){
                    //花了5秒做包子
                    try {
                        Thread.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //做好包子之后 调用notify方法唤醒顾客吃包子
                    保证等待和唤醒的线程只能有一个在执行 使用同步技术（同步代码块）
                    synchronized (object){
                        System.out.println("5秒做包子 做好包子之后,告诉顾客吃包子了");

                        object.notify();
                    }
                }
            }
        }.start();

    }
}

运行结果
告知老板包子的种类和数量
5秒做包子 做好包子之后,告诉顾客吃包子了
包子做了 吃吧
========================
告知老板包子的种类和数量
5秒做包子 做好包子之后,告诉顾客吃包子了
包子做了 吃吧

......
......
循环
.........

Object类中的Wait带参方法以及notifyAll方法

void wait(long timeout)

在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。

void notifyAll()

 唤醒在此对象监视器上等待的所有线程。

package lwq.day06.WaitAndNotify;

/**
 * @author: LWQ
 * @description
 * @date: 2021/9/6 10:37
 */
/*
进入到TimeWaiting(计时等待)有两种方法
1 使用sleep（long m）方法 在毫秒值结束后 线程唤醒进入到Runnnable/Blocked状态
2 使用wait（long m）方法 wait方法如果在毫秒值结束之后 还没有被notify唤醒 就会自动醒来 线程睡醒进入Runnable Blocked状态


唤醒的方法： void notify（） 唤醒在此对象监视器上等待的单个线程。
            void notifyAll() 唤醒在此对象监视器上等待的所有线程。
 */
public class Demo02WaitAndNotify {
    public static void main(String[] args) {
        //1 创建锁对象保证唯一
        Object object = new Object();

        //2创建一个顾客线程（消费者）
        new Thread(){
            //重写Objects类中的run方法
            @Override
            public void run() {

                //一直等着买包子
                while (true){
                    //保证等待和唤醒的线程只能有一个在执行 使用同步技术（同步代码块）
                    synchronized (object){
                        System.out.println("顾客 1 告知老板包子的种类和数量");
                        //调用wait方法 放弃cpu的值行 进入到waiting状态（无限等待状态）
                        try {
                            //object.wait(5000);//相当于5000毫秒之后 老板没说 自动唤醒
                            object.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子做了 顾客1 吃吧");
                        System.out.println("========================");
                    }
                }

            }
        }.start();




        //2创建一个顾客线程（消费者）
        new Thread(){
            //重写Objects类中的run方法
            @Override
            public void run() {

                //一直等着买包子
                while (true){
                    //保证等待和唤醒的线程只能有一个在执行 使用同步技术（同步代码块）
                    synchronized (object){
                        System.out.println("顾客 2 告知老板包子的种类和数量");
                        //调用wait方法 放弃cpu的值行 进入到waiting状态（无限等待状态）
                        try {
                            object.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //唤醒之后执行的代码
                        System.out.println("包子做了 顾客2 吃吧");
                        System.out.println("========================");
                    }
                }

            }
        }.start();


        //创建一个老板线程（生产者）：
        new Thread(){
            重写Objects类中的run方法
            @Override
            public void run() {

                // 一直做包子
                while (true){

                    try {
                        Thread.sleep(5000);//花了5秒做包子
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    //做好包子之后 调用notify方法唤醒顾客吃包子
                    保证等待和唤醒的线程只能有一个在执行 使用同步技术（同步代码块）
                    synchronized (object){
                        System.out.println("5秒做包子 做好包子之后,告诉顾客吃包子了");

                        //object.notify()唤醒在此对象监视器上等待的单个线程。
                        object.notifyAll();//唤醒在此对象监视器上等待的所有线程。
                    }
                }
            }
        }.start();
    }
}

输出结果：
object.notify()唤醒在此对象监视器上等待的单个线程
顾客 1 告知老板包子的种类和数量
顾客 2 告知老板包子的种类和数量
5秒做包子 做好包子之后,告诉顾客吃包子了
包子做了 顾客1 吃吧
========================
顾客 1 告知老板包子的种类和数量
5秒做包子 做好包子之后,告诉顾客吃包子了
包子做了 顾客2 吃吧
========================
顾客 2 告知老板包子的种类和数量
5秒做包子 做好包子之后,告诉顾客吃包子了
包子做了 顾客1 吃吧
========================
顾客 1 告知老板包子的种类和数量

输出结果：
object.notifyAll();唤醒在此对象监视器上等待的所有线程。

顾客 1 告知老板包子的种类和数量
顾客 2 告知老板包子的种类和数量
5秒做包子 做好包子之后,告诉顾客吃包子了
包子做了 顾客1 吃吧
========================
顾客 1 告知老板包子的种类和数量
包子做了 顾客2 吃吧
========================
顾客 2 告知老板包子的种类和数量
5秒做包子 做好包子之后,告诉顾客吃包子了
包子做了 顾客1 吃吧
========================
顾客 1 告知老板包子的种类和数量
包子做了 顾客2 吃吧
========================
顾客 2 告知老板包子的种类和数量