Java学习笔记（四十二）—— 线程的状态(Thread.State类)

最新推荐文章于 2024-10-17 22:59:11 发布
最新推荐文章于 2024-10-17 22:59:11 发布
阅读量520 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44876003/article/details/103272813
版权
Thread.State类

Thread.State线程状态。 线程可以处于以下状态之一：

  • NEW
    • 尚未启动的线程处于此状态。
  • RUNNABLE
    • 在Java虚拟机中执行的线程处于此状态。
  • BLOCKED
    • 被阻塞等待监视器锁定的线程处于此状态。
  • WAITING
    • 正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING
    • 正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED
    • 已退出的线程处于此状态。

一个线程可以在给定时间点处于一个状态。 这些状态是不反映任何操作系统线程状态的虚拟机状态。

线程之间的通信

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

    /*
    Object类中的方法：
        wait​()，导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。
        notify​()，唤醒正在等待对象监视器的单个线程。

*/
	wait​()
	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("执行唤醒后的线程"); // 执行顺序3
            }
        }
    }.start();
    new Thread(){
        @Override
        public void run() {

            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj){
                System.out.println("唤醒等待执行的线程"); // 执行顺序2
                obj.notify(); // 随机唤醒等待的线程中的一个
            }
        }
    }.start();

  2. 进行TimeWaiting(计时等待)

    /*
    进行TimeWaiting（计时等待）的两种方式
        1、使用sleep(long m)方法，在毫米值结束之后，线程睡醒进入到Runnable/Blocked状态
        2、使用wait(long m)方法，在毫米值结束后，线程还没有被notify唤醒就会自动醒来，
            线程睡醒进入到Runnable/Blocked状态
*/
    public static void main(String[] args) {
        Object obj=new Object();
        new Thread(){
            @Override
            public void run() {
                // 保证等待和唤醒的进程只能有一个执行
                synchronized (obj){
                    System.out.println("正在执行的线程");
                    try {
                        obj.wait(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 唤醒后执行的代码
                    System.out.println("执行唤醒后的线程");
                }
            }
        }.start();
	}

     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("唤醒等待执行的线程");
                obj.notifyAll(); // 唤醒所有等待的线程
            }
        }
    }.start();
}

  3. 线程之间的通信：多个线程在处理同一个资源，但是处理的动作（线程的任务）不同
           多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务， 并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

  4. 等待与唤醒机制：就是在一个线程进行了规定操作后，就进入等待状态（wait）， 等待其他线程执行完他们的指定代码过后 再将其唤醒（notify）。即多个线程在操作同一份数据时， 避免对同一共享变量的争夺。

    /*
调用notify方法：
	如果能获取锁，线程从WAITING状态变为RUNNABLE状态；
	否则线程从wait set出来，又进入entry set，线程从WAITING状态变为BLOCK状态
*/
/*
调用wait和notify方法需要注意的事项:
	I、必须有同一个锁对象调用
	II、都是Object类的方法
	III、都必须在同步代码块或者同步函数中使用
*/

    public class BaoZi {
    String pi;
    String xian;
    boolean flag=false;
}

    public class BaoZiPu extends Thread{
    private BaoZi bz;
    public BaoZiPu(BaoZi bz){
        this.bz=bz;
    }
    @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();
                }
                bz.flag = true;
                bz.notify();
                System.out.println("包子已经生产好了");

            }
        }
    }
}

    public class ChiHuo extends Thread {
    private BaoZi bz;
    public ChiHuo(BaoZi bz){
        this.bz=bz;
    }

    @Override
    public void run() {
        while (true){
            synchronized (bz){
                if(bz.flag==false){
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("吃货正在吃"+bz.pi+bz.xian+"包子");
                bz.flag=false;
                bz.notify();
                System.out.println("吃货已经把包子吃完了，包子铺开始生成包子");
                System.out.println("------------");
            }
        }
    }
}

    public class demo {
    public static void main(String[] args) {
        BaoZi bz= new BaoZi();
        new BaoZiPu(bz).start();
        new ChiHuo(bz).start();
    }
}
线程池
  1. 概述：容纳道光线程的容器–> 集合（ArrayList，HashSet，LinkedList，HashMap）
  2. Executors类：工厂和工具方法Executor ， ExecutorService ， ScheduledExecutorService ， ThreadFactory和Callable此包中定义的类。是线程池的工程类
  3. Executors的静态方法
    3.1 newFixedThreadPool​(int nThreads)，创建一个线程池，该线程池重用固定数量的从共享无界队列中运行的线程。
    /*
 参数：
 	int nThread--创建线程池中包含的线程数量
 返回值：
 	ExecutorService接口，返回的是ExecutorService接口的实现类对象，可以使用ExecutorService接口来接收（面向接口编程）
 ExecutorService：线程池接口，用来从线程池中获取线程，调用start方法，执行线程任务。
 	submit​(Runnable task) 提交一个可运行的任务执行，并返回一个表示该任务的未来。 
 线程池的使用方法：
 	1、使用线程池的工厂类Executors里面的newFixedThreadPool生成一个指定线程数量的线程池
 	2、创建一个类，实现Runable接口，重写run方法，设置线程任务
 	3、调用ExecutorService中的方法submit，传递线程任务（实现类），开启线程执行run方法
 	4、调用ExecutorService中的shutdown方法，销毁线程池。
 		shutdown​()，启动有序关闭，其中先前提交的任务将被执行，但不会接受任何新任务。 
*/
    // 1.
    ExecutorService es= Executors.newFixedThreadPool(2);
    // 3.
    es.submit(new RunableImpl()); // pool-1-thread-1创建了新线程
    es.submit(new RunableImpl()); // pool-1-thread-2创建了新线程
    es.submit(new RunableImpl()); // // pool-1-thread-2创建了新线程
    // 4.
	es.shutdown

    // 2.
public class RunableImpl implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"创建了新线程");
    }
}
miles-zh
关注
专栏目录
java中线程的状态学习笔记
08-26
Java中的线程状态学习笔记 Java中的线程状态是指线程在其生命周期中所经历的一系列状态。在Java开发中，了解线程的状态是非常重要的，因为它可以帮助我们更好地理解线程的行为和生命周期。下面我们将详细介绍Java中...
Java Thread.State 线程状态
小旺财的博客
02-12 583
Java Thread.State 线程状态。 获取线程的状态：thread.getState ();
Java并发10:线程的状态Thread.State及其线程状态之间的转换
韩超的博客 (hanchao5272)
03-12 9923
[超级链接：Java并发学习系列-绪论] 本章主要对Java中线程的状态转换进行学习。 1.前言 在之前的章节中，已经学习了java的各种方法，涉及到状态转换的方法有： Thread.sleep(long)：强制线程睡眠一段时间。 thread.start()：启动一个线程。 thread.join()：在当前线程中加入指定线程，使得这个指定线程等待当前线程，并在当前线程结束前结束。 t...
Java线程状态（Thread.State）
Lyhdreamer的博客
06-11 1051
当前线程sleep()方法结束，其他线程join()结束，某个线程拿到对象锁，这些线程也将进入就绪状态。当线程调度程序从可运行池中选择一个线程作为当前线程时，线程进入运行状态，此时线程占有CPU资源并在CPU上运行。线程进入等待状态，是因为它调用了其他线程的join()方法，或者调用了无参数的wait()方法。线程进入定时等待状态，是因为它调用了sleep()或者带有指定时间的wait()或join()方法。（1）当线程执行完毕，即线程执行完所有的代码后，线程会自动终止。
ThreadState
小文panda的专栏
09-26 1086
当一个ThreadState刚刚被创建的时候，它的Threads
[Thread,Thread State]线程,线程状态
Cui's Blog
02-23 663
线程 线程 & 进程 学过操作系统的基本都知道这个词。一开始出现的是进程，进程是操作系统中分时系统的一个基本运作单位。但是后来由于系统设计的升级，对进程又进行了划分，所以出现了线程。 进程可以包含多个线程，至少一个。这样就出现了线程来执行用户需要执行的命令。区别总结一下： 进程是一段正在执行的程序，是资源分配的基本单元，而线程时CPU调度的基本单元。 进程间相互独立，进程与进程之间不能共享资源，一个进程至少有一个线程，同一个进程的各线程共享整个进程的资源(寄存器，堆栈，上下文)。 线程的创建和
Java多线程源码笔记.pdf
05-08
1. Thread类解析：Thread类是Java多线程的基础，它拥有start()方法来启动线程，run()方法用来执行线程的逻辑。通过重写run()方法，你可以定义线程执行的具体任务。 2. 使用多线程需要注意的问题：多线程环境下，...
state threads学习笔记.docx
06-28
### 协程库State Threads Library (ST) 学习笔记 #### 一、引言 在探讨协程库State Threads Library（简称ST）之前，我们首先需要了解几个基础概念：协程、用户线程以及它们如何帮助提升软件的并发性能。 #### 二...
JAVA 多线程学习笔记
03-27
这篇学习笔记将深入探讨Java多线程的核心概念、实现方式以及相关工具的使用。 一、多线程基础 1. 线程与进程：在操作系统中，进程是资源分配的基本单位，而线程是程序执行的基本单位。每个进程至少有一个主线程，...
学习多线程使用这个笔记就够了
02-02
Java提供了`Thread.State`枚举来表示这些状态。 **8. 线程调度** - **协同式调度**：线程自行控制执行时间，可能导致系统阻塞。 - **抢占式调度**：Java采用的方式，由系统决定线程执行时间，更可控。 **9. 线程...
Thread线程状态以及常用方法
嘴巴吃糖了
03-21 358
这个方法多加了纳秒级别的延时参数，但是我们看源码就知道，这个多加的纳秒级别的延时参数并没有什么用，最终该函数还是调用了上面的单参数sleep方法，延时还是毫秒级别的。多出来的参数最多是让当前毫秒级别的延时增加1毫秒。
Thread.State 介绍
yh_zeng2的博客
01-18 654
JDK api官方文档中给出的Thread.State的说明如下： A thread state. A thread can be in one of the following states: NEW A thread that has not yet started is in this state. RUNNABLE A thread executing in the
线程状态
weixin_45683851的博客
11-28 145
线程状态 1.线程状态转换图 2.线程状态的进一步理解 new：Thread thread = new Thread()，线程对象一旦创建好了，就进入了新生状态； 就绪状态：当调用start()方法，线程立即进入就绪状态，但是这并不意味着该线程会立即被CPU调度执行； 运行状态：线程被CPU调度执行后，才算真正进入运行状态，线程才真正执行线程体的代码块； 阻塞状态：当调用sleep()、wait...
多线程2——线程状态、Thread类API
yuiop123455的博客
08-27 175
一级标题 二级标题 三级标题
三个实例演示 Java Thread Dump 日志分析
weixin_33709219的博客
01-06 1090
jstack Dump 日志文件中的线程状态 dump 文件里，值得关注的线程状态有： 死锁，Deadlock（重点关注）  执行中，Runnable    等待资源，Waiting on condition（重点关注）  等待获取监视器，Waiting on monitor entry（重点关注） 暂停，Suspended 对象等待中，Object.wait() 或 TIMED...
线程（thread）
weixin_30677475的博客
07-24 250
线程概述 线程是一个独立处理的执行路径。每个线程都运行在一个操作系统进程中，这个进程是程序执行的独立环境。在单线程中进程的独立环境内只有一个线程运行，所以该线程具有独立使用进程资源的权利。在多线程程序中，在进程中有多个线程运行，所以它们共享同一个执行环境。 基础线程（thread） 使用Thread类可以创建和控制线程,定义在System.Threading命名空间中: 1 ...
再说多线程（六）——Thread生命周期
q__y__L的博客
02-10 727
前面一直在用Thread介绍多线程任务，本节对线程类Thread的生命周期进行简单的梳理。
Java多线程之线程状态
Lanna_w的博客
08-06 242
Java多线程之线程状态
在C#中，ThreadState
最新发布
j17805056906的博客
10-17 285
然而，由于 `Thread.Abort` 在现代.NET代码中通常被认为是不安全的，因此这个状态在现代应用中很少见到。在现代.NET开发中，通常建议使用更高级的并发编程模型（如 `Task` 并行库、`async`/`await` 模式）来处理并发任务，而不是直接使用 `Thread` 类和 `ThreadState` 枚举。直接操作线程状态（如使用 `Suspend`、`Resume`、`Abort` 和 `Stop` 方法）通常是不安全的，并可能导致不可预测的行为和资源泄露。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值