线程的状态及其转化

最新推荐文章于 2024-09-09 23:23:36 发布
最新推荐文章于 2024-09-09 23:23:36 发布
阅读量334 收藏
点赞数
分类专栏： Java并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43185543/article/details/102990413
版权

当Thread对象创建完成时，线程的生命周期便开始了。当线程任务中代码正常执行完毕或者线程抛出一个未捕获的异常或者错误时，线程的生命周期便会结束。
Java中线程的状态可以分为6个状态，分别是NEW(新建状态)、RUNNABLE(可运行状态)、BLOCKED(阻塞状态)、WAITING(等待状态)、TIMEDWAITING(定时等待状态)、TERMINATED(终止状态)。
1.NEW(新建状态)
创建一个线程对象后，该线程对象就处于新建状态，此时它不能运行，和其它Java对象一样，仅仅由JVM为其分配了内存，没有表现出任何线程的动态特征。
2.RUNNABLE(可运行状态)
当新建状态下的线程对象调用了start()方法，此时就会从新建状态进入可运行状态。在RUNNABLE状态内部又可细分为两种状态：READY(就绪状态)和RUNNING(运行状态)，并且线程可以在这两个状态之间相互转换。
就绪状态：线程对象调用start()方法之后，等待JVM的调度，此时线程并没有运行；
运行状态：线程对象获得JVM调度，如果存在多个CPU，那么允许多个线程并行运行。
3.BLOCKED(阻塞状态)
处于运行状态的线程可能会由于某些原因失去CPU的执行权，暂时停止运行进入阻塞状态。此时JVM不会给线程分配CPU，直到线程重新进入就绪状态，才有机会转换到运行状态。阻塞状态的线程只能先进入就绪状态，不能直接进入运行状态。
线程一般会在以下两种情况下进入阻塞状态：
1>当线程A运行过程中，试图获取同步锁时，却被线程B获取，此时JVM把当前线程A存到对象的锁池中，线程A就会进入阻塞状态；
2>当线程运行过程中，发出I/O请求时，此时线程也会进入阻塞状态。
4.WAITING(等待状态)
当处于运行状态的线程调用了无时间参数限制的方法后，如wait()、join()等方法，就会将当前运行中的线程转换为等待状态。
处于等待状态中的线程不能立即争夺CPU使用权，必须等待其它线程执行特定的操作后，才有机会再次争夺CPU使用权，将等待状态的线程转换为运行状态。例如，调用wait()方法而处于等待状态中的线程，必须等待其它线程调用notify()或者notifyAll()方法唤醒当前等待中的线程；调用join()方法而处于等待状态中的线程，必须等待其它加入的线程终止。
5.TIMEDWAITING(定时等待状态)
当运行状态中的线程转换为定时等待状态中的线程与转换为等待状态中的线程操作类似，只是运行线程调用了有时间参数限制的方法，如sleep(long millis)、wait(long timeout)、join(long millis)等方法。
处于定时等待状态中的线程也不能立即争夺CPU的使用权，必须等待其它相关线程执行完特定的操作或者限时结束后，才有机会再次争夺CPU的使用权，将定时等待状态的线程转换为运行状态。例如，调用了wait(long timeout)方法而处于等待状态中的线程，需要通过其它线程调用notify()或者notifyAll()方法唤醒当前等待中的线程，或者等待限时结束后也可以进行状态转换。
6.TERMINATED(终止状态)
线程中的run()方法、call()方法正常执行完毕或者线程抛出一个未捕获的异常、错误，线程就进入终止状态。一旦进入终止状态，线程将不再拥有运行的资格，也不能转换到其它状态，生命周期结束。


public class ThreadState {
    public static void main(String[] args) {
        for (Thread.State state : Thread.State.values()) {
            System.out.println(state);
        }
    }
}

运行结果：
在这里插入图片描述
线程状态转换图：
在这里插入图片描述
例1：验证NEW、RUNNABLE和TERMINATED


import java.util.SortedMap;

class MyThread extends Thread{
    public MyThread(){
        System.out.println("构造方法中的状态: Thread.currentThread().getState()="+Thread.currentThread().getState());
        System.out.println("构造方法中的状态：this.getState()="+this.getState());
    }
    @Override
    public void run(){
        System.out.println("run方法中的状态："+Thread.currentThread().getState());
    }
}
public class Run1 {
    public static void main(String[] args) {
        try {
            MyThread mythread=new MyThread();
            System.out.println("main方法中的状态1："+mythread.getState());
            Thread.sleep(1000);
            mythread.start();
            Thread.sleep(1000);
            System.out.println("main方法中的状态2："+mythread.getState());
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
}

运行结果：
在这里插入图片描述
例2：验证NEW、RUNNABLE和TERMINATED


public class Run2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 1000_0000; i++) {

            }
            }, "李四");
        System.out.println(t.getName() + ": " + t.getState());;
        t.start();
        while (t.isAlive()) {
            System.out.println(t.getName() + ": " + t.getState());;
        }
        System.out.println(t.getName() + ": " + t.getState());;
    }
}

运行结果：
李四: NEW
…
李四: RUNNABLE
…
李四: TERMINATED
例3：验证 WAITING 、 BLOCKED 、 TIMED_WAITING


public class Run3 {
    public static void main(String[] args) throws InterruptedException {
        Object object = new Object();
        Thread t = new Thread(() -> {
            synchronized (object) {
                try {object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < 1000_0000; i++) {

                }
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        System.out.println(t.getState());;
        t.start();
        System.out.println(t.getState());
        Thread.sleep(10);
        synchronized (object) { for (int i = 0; i < 10; i++) {
            System.out.println(t.getState());
        }
        object.notify();
        }
        while (t.isAlive()) {
            System.out.println(t.getState());
        }
    }
}

运行结果：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
例4： yield() 大公无私，让出 CPU


public class Run4 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            while (true) {
            System.out.println(Thread.currentThread().getName() + ": 我跑着呢");
            // Thread.yield();
                }
        }, "李四");
        Thread thread2 = new Thread(() -> {
            while (true) {
            System.out.println(Thread.currentThread().getName() + ": 我跑着呢");
            }
        }, "王五");
        thread1.start();
        thread2.start();
    }
}

运行结束：

  1. yield() 只是让出 CPU，并不会改变自己的状态。也就上面途中，我从柜台前站起，又重新去排队去了
  2. 因为李四总是无私的让出座位，王五并不让座位，所以会导致王五打印的更多。
    例5：验证TIMED_WAITING

//线程状态TIMED_WAITING代表线程执行了Thread.sleep()方法，呈等待状态，等待时间到达，然后继续向下运行。
//执行sleep()方法后线程的状态枚举值就是TIMED_WAITING。
 class Mythread2 extends Thread{
    @Override
    public void run() {
        try{
            System.out.println("begin sleep");
            Thread.sleep(1000);
            System.out.println("end sleep");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class Run5 {
    public static void main(String[] args) {
        try{
            Mythread2 mythread2=new Mythread2();
            mythread2.start();
            Thread.sleep(1000);
            System.out.println("main方法中的状态： "+mythread2.getState());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

运行结果：
在这里插入图片描述
例6：验证BLOCKED


//BLOCK状态出现在某个线程在等待锁的时候。
//从运行结果来看mythread32线程一直在等待mythread31对锁进行释放，所以mythread32当时处于BLOCKED状态。
 class MyService{
    synchronized static public void serviceMethod(){
        try{
            System.out.println(Thread.currentThread().getName()+"进入了业务方法");
            Thread.sleep(10000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

 class MyThread31 extends Thread{
    @Override
    public void run() {
        MyService.serviceMethod();
    }
}

 class MyThread32 extends Thread{
    @Override
    public void run() {
        MyService.serviceMethod();
    }
}

public class Run6 {
    public static void main(String[] args) throws InterruptedException{
        MyThread31 mythread31=new MyThread31();
        mythread31.setName("a");
        mythread31.start();
        Thread.sleep(1000);
        MyThread32 mythread32=new MyThread32();
        mythread32.setName("b");
        mythread32.start();
        Thread.sleep(1000);
        System.out.println("main方法中没有thread21状态："+mythread32.getState());
    }
}

运行结果：
在这里插入图片描述
例7：验证WAITING

//WAITING状态是线程执行了Object.wait()方法后所处的状态。
//执行wait()方法后线程状态枚举值就是WAITING。

class Lock{
    static final Byte lock=new Byte("0");
}
class Mythread7 extends Thread{

    @Override
    public void run() {
        try {
            synchronized (Lock.lock){
                Lock.lock.wait();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
public class Run7 {
    public static void main(String[] args) {
        try{
            Mythread7 mythread7=new Mythread7();
            mythread7.start();
            Thread.sleep(1000);
            System.out.println("main方法中的mythread7状态： "+mythread7.getState());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

运行结果：
在这里插入图片描述

hi168
关注
专栏目录
嵌入式100题（006）：进程线程的状态转换
SWK_dy的博客
02-24 643
进程线程的状态转换图 进程 创建状态(New)：一个应用程序从系统上启动，首先就是进入创建状态，需要获取系统资源创建进程管理块（PCB：Process Control Block）完成资源分配。 就绪状态(Runnable)：在创建状态完成之后，进程已经准备好，但是还未获得处理器资源，无法运行。 运行状态(Running)：获取处理器资源，被系统调度，开始进入运行状态。如果进程的时间片用完了就进入就绪状态。 阻塞状态(Blocked)：在运行状态期间，如果进行了阻塞的操作，如耗时的I/O操作，此时进程暂时
Java线程生命周期模型及各状态详解
kirain的博客
12-08 187
Java线程生命周期模型有NEW,RUNABLE,BLOCKED,WAITING,TIMED_WAITING,TERMINATED，六个状态，本文详细解释了这六个状态及其相互转化
线程的状态转换
最自由的笑的博客
08-09 301
线程的五种状态（操作系统层面） 初始状态：创建线程，分配资源，但还没有调度到就绪队列。 就绪状态：线程已经被创建，等待获取cpu调度执行。 运行状态：正在使用cpu执行的状态，当时间片用完，会由运行态变为就绪态。 阻塞状态：线程暂时丢失cpu使用权的状态，比如发生io操作 等待锁。 终止状态：线程已经执行完毕。 线程的六种状态（java层面） 新建状态 NEW，线程创建之后还没有调用start方法就是这种状态。 运行状态 RUNNABLE：它包含了操作系统层面的就绪 运行 以及io阻塞状态，在Jav
JAVA 线程状态及转化
weixin_34129145的博客
03-20 251
线程状态图 说明：线程共包括以下5种状态。1.新建状态(New) : 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。2.就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被...
面试篇-JUC
最新发布
m0_62736966的博客
09-09 49
1.原子性：提供互斥访问，同一时刻只能有一个线程对数据进行操作，在java中使用了atomic和synchronized这两个关键字来确保原子性；2.可见性：一个线程对主内存的修改可以及时地被其他线程看到，在)ava中使用了synchronized和volatile这两个关键字确保可见性；3.有序性：一个线程观察其他线程中的指令执行顺序，由于指令重排序，该观察结果一般杂乱无序，在Java中使用了happens-before原则来确保有序性。
线程状态及转换
江七
08-11 766
一、线程状态概述 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中， 有几种状态呢？在API中 java.lang.Thread.State 这个枚举中给出了六种线程状态： 这里先列出各个线程状态发生的条件，下面将会对每种状态进行详细解析 。 线程状态 导致状态发生条件 NEW(新建) 线程刚被创建，但是并未启动。还没调用start方法。 Runnable(可运行) 线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，
线程的状态和转换
weixin_33697898的博客
05-02 142
一、线程的6种状态 Java语言定义了6种线程状态 public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; } 新建（New） 线程创建后尚未启动。 可...
线程状态及其转换
小仙女的博客
09-18 247
线程的基本状态 1. 新建状态(New)         : 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。 2. 就绪状态(Runnable):线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。 3. 运行状态(Running) : 线程获取CPU权限进行执行。 4. 阻塞状态(Blocked)  : 阻塞状...
Java学习教程-探究JAVA线程状态及转化视频
06-16
在Java中，线程的状态及其转换是非常关键的概念，理解和掌握这些可以帮助我们编写出更加高效、稳定的多线程程序。本教程将深入探讨Java线程的五种基本状态以及它们之间的转换。 1. **新建（New）**：当使用`Thread`...
线程的状态有哪几种？他们之间是如何转换的？
dean1966的博客
03-05 2392
线程的状态有哪几种？他们之间是如何转换的？ 目录 1、线程状态分类 2、状态详解 2.1、状态 1：NEW 2.2、状态 2：RUNNABLE 2.3、状态 3：BLOCKED 2.4、状态 4：WAITING 2.5、状态 5：TIMED_WAITING 2.6、状态 6：TERMINATED 3、状态转换图 1、线程状态分类 线程一共有六种状态，分别为 New、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED，同一时刻只有一种状态，通过线程的 getSt
简述程序、进程、线程之间关联以及概念； Java中线程由哪些组成部分？ Java中提供哪些创建线程方式？创建方法是什么？ 线程生命周期有哪些状态？描述状态间转化过程； 简述线程状态转换的常用方法及其效果； 简述Java中线程同步机制和实现同步方法； 什么是死锁？产生原因是什么？ 为什么要进行线程通信？Java中线程通信主要方法是什么？
06-05
5. 线程状态转换的常用方法及其效果： - sleep(): 使当前线程暂停指定的时间，进入阻塞状态，不会释放锁。 - yield(): 让出当前线程的CPU时间片，让其他线程有机会执行，但不会释放锁。 - wait(): 使当前线程进入...
线程的几种状态转换
Qgchun.
01-30 1023
线程转换
线程的状态有哪几种？它们之间是如何转换的？
weixin_50216347的博客
03-20 2226
线程的状态有哪几种？它们之间是如何转换的？ 1、线程状态分类 线程一共有六种状态，分别为 New、RUNNABLE、BLOCKED、WAITING、TIMED_WAITING、TERMINATED，同一时刻只有一种状态，通过线程的 getState 方法可以获取线程的状态。 2、状态详解 Thread的状态使用 java.lang.Thread.State 枚举表示。 2.1、状态1：NEW 当线程被创建出来还没有调用 start() 状态时。 public class NewState { pu.
线程状态切换
weixin_53854631的博客
02-04 752
未完待续
线程状态之间的转换
小王子的博客
03-23 709
关于线程状态，网上也是众说风云，以下说到的六种状态来自jdk1.8帮助文档，线程随时可处于以下状态之一： NEW 尚未启动的线程处于此状态。 RUNNABLE 在Java虚拟机中执行的线程处于此状态。 BLOCKED 被阻塞等待监视器锁定的线程处于此状态。 WAITING 正在等待另一个线程执行特定动作的线程处于此状态。 TIMED_WAITING 正在等待另一个线程执行动作达到指定等待时间的线...
线程之间状态和转换
梵城专栏
11-21 2267
线程创建之后并不是直接开始运行的,而是分了各种状态以便于管理,这样想,cpu就一个,及时你的电脑是4核或者8核,那么也只能同时运行这么多,但是你开启的线程那么多,怎么保证每个都运行呢,那么就必须进行管理.线程状态分为创建,就绪,运行和阻塞和结束五个状态. 创建:这个状态是线程刚刚创建,只是在堆内存中分配了空间. 就绪:这是的线程已经执行了start()方法,等待获取cpu的运行权限. 运行:这个时候
Java线程：线程状态的转换
weixin_34296641的博客
09-13 353
Java线程：线程状态的转换   SCJP5学习笔记   一、线程状态   线程的状态转换是线程控制的基础。线程状态总的可分为五大状态：分别是生、死、可运行、运行、等待/阻塞。用一个图来描述如下：   1、新状态：线程对象已经创建，还没有在其上调用start()方法。   2、可运行状态：当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当start...
thread与runnable的区别
ly4513的专栏
12-26 690
线程的几种状态  　　在Java当中，线程通常都有五种状态，创建、就绪、运行、阻塞和死亡。  　　第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。  　　第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪
Java多线程深度解析：从基础到实践
书中涵盖了从基础到高级的多线程概念，包括进程与线程的基本概念、Java多线程的入门、线程组和优先级、线程状态及其转化、线程间通信、Java内存模型、同步机制、并发工具等内容。 1. 进程与线程基本概念： - 进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值