一文详解Java线程的6种状态与生命周期

目录1.线程状态（生命周期）2.操作线程状态2.1.新创建sFchWnoLjs状态（NEW）2.2.可运行状态（RUNNABLE）2.3.被阻塞状态（BLOCKED）2.4.等待唤醒状态（WAITING）2.5.计时等待状态（TIMED_WAITING）2.6.终止（TERMINATED）3.查看线程的6种状态

1.线程状态（生命周期）

一个线程在给定的时间点只能处于一种状态。

线程可以有如下6 种状态：

New (新创建）：未启动的线程；Runnable (可运行）：可运行的线程，需要等待操作系统资源；Blocked (被阻塞）：等待监视器锁而被阻塞的线程；Waiting (等待）：等待唤醒状态，无限期地等待另一个线程唤醒；Timed waiting (计时等待）：在指定的等待时间内等待另一个线程执行操作的线程；Terminated (被终止）：已退出的线程。

要确定一个线程的当前状态， 可调用getState 方法

线程状态关系图

注意：虚线框（全大写英文）的状态为java线程状态。

2.操作线程状态

2.1.新创建状态（NEW）

就是实例化线程完成后，未启动线程的状态。

可通过三种方式创建线程

重写Thread类run()方法实现Runnable接口实现Callable接口

一个简单的例子概括三种方式

publicclassDemo{

publicstaticvoidmain(String[]args)throwsExecutionException,InterruptedException{

/**

*1.直接重写run()或继承Thread类再重写run()

*/

Threadthread=newThread(){

@Override

publicvoidrun(){

System.out.println("Thread");

}

};

//开启线程

thread.start();

/**

*2.lambda、内部类或线程类方式实现Runnable接口，实现run()方法

*再交给Thread类

*/

ThreadrunThread=newThread(()->{

System.out.println("Runnable");

});

//开启线程

runThread.start();

/**

*3.lambda、内部类或线程类方式实现Callable接口，实现call()方法

*再交给Thread 类：FutureTask本质也是Runnable实现类

*/

FutureTaskfutureTask=newFutureTask(()->{

System.out.println("Callable");

return"CallableThread";

});

ThreadcallThread=newThread(futureTask);

//开启线程

callThread.start();

//获取call()方法的返回值

Strings=futureTask.get();

System.out.println("call()方法的返回值："+s);

}

}

不重写 run() 或 call() 方法直接实例化Thread类创建的线程没有实际意义；

只有Callable方式创建的线程可以获取线程的返回值。

2.2.可运行状态（RUNNABLE）

该状态指的是线程实例化对象调用start()方法后进入的状态。线程处于可以运行状态，如果有处理器等资源，就可以执行程序。

该状态在操作系统层面包含两步：线程就绪和线程运行中，但在Java线程状态中，这两步都统称为Runnable（可运行）状态。

线程由就绪状态变为运行状态，重点就看你的线程有没有抢到CPU资源（CPU时间片），谁抢到就运行，没抢到就等。因为CPU时间片（执行时间）非常短，大概十几毫秒，所以线程切换的这个时间是非常短的，就绪状态变为运行状态的时间也非常短，在开发时几乎感觉不到这种状态的变化，所以在Java中将两者看作是一个整体，重点关注线程可否运行并区别于其他状态即可，更进一步简化线程的开发。如果你的程序要运行很久（比如写个死循环），在一个CPU时间片内没有执行完成，那么你的线程就要抢下一次的CPU时间片，抢到了才可以继续执行程序，没抢到那就要继续抢，直到线程中的程序执行完成。

其实这个场景应该都见到过，例如多个线程执行同一个程序，都将日志打印到同一个文件时，就会出现不同线程的日志混在了一起的情况，不利于排查问题。解决这种问题常见的方法有：一是分线程打印日志到不同文件；二是将日志信息保存到字符串对象中，在程序的最后将日志信息一次性打印到文件。第二种方式就是利用CPU的一个时间片来完成日志信息的打印。

注意：程序只能对新建状态的线程调用start()方法，不要对处于非新建状态的线程调用start() 方法，这都会引发IllegalThreadStateException异常。

2.3.被阻塞状态（BLOCKED）

线程处于等待监视器锁而被阻塞的状态。有一个线程获取了锁未释放，其他线程也来获取，但发现获取不到锁也进入了被阻塞状态。

被阻塞状态只存在于多线程并发访问下，区别于后面两种因线程自己进入”等待“而导致的阻塞。

进入状态

进入synchronized 代码块/方法未获取到锁

退出状态

获取到监视器锁

2.4.等待唤醒状态（WAITING）

整个流程是这样的：线程在某个对象的同步方法中先获取到对象锁；在执行wait方法时，该线程将释放对象锁，并且该线程被放入到这个对象的等待队列；等待另一个线程获取到同一个对象的锁，然后通过notify() 或 notifyAll() 方法唤醒对象等待队列中的线程。

从整个流程可以知道

wait (),notify () 和 notifyAll () 方法需要在线程获取到锁的情况下才可以继续执行，所以这三个方法都需要放在同步代码块/方法中执行，否则报异常：java.lang.Ihttp://llegalMonitorStateException。

在同步代码块中，线程进入WAITING 状态时，锁会被释放，不会导致该线程阻塞。反过来想下，如果锁没释放，那其他线程就没办法获取锁，也就没办法唤醒它。

进入状态

object.wait()thread.join()LockSupport.park()

退出状态

object.notify()object.notifyall()LockSupport.unpark()

2.5.计时等待状态（TIMED_WAITING）

一般是计时结束就会自动唤醒线程继续执行后面的程序，对于Object.wait(long) 方法还可以主动通知唤醒。

注意：Thread类下的sleep() 方法可以放在任意地方执行；而wait(long) 方法和wait() 方法一样，需要放在同步代码块/方法中执行，否则报异常：java.lang.IllegalMonitorStateException。

进入状态

Thread.sleep(long)Object.wait(long)Thread.join(long)LockSupport.parkNanos(long)LockSupport.parkNanos(Object blocker, long nanos)LockSupport.parkUntil(long)LockSupport.parkUntil(Object blocker, long deadline)

注：blocker 参数为负责此线程驻留的同步对象。

退出状态

计时结束LockSupport.unpark(Thread)object.notify()object.notifyall()

2.6.终止（TERMINATED）

线程执行结束

run()/call() 执行完成stop()线程错误或异常>>意外死亡

stop() 方法已弃用。

3.查看线程的6种状态

通过一个简单的例子来查看线程出现的6种状态。

案例

publicclassDemo3{

privatestaticObjectobject="obj";

publicstaticvoidmain(String[]args)throwsInterruptedException{

Threadthread0=newThread(()->{

try{

//被阻塞状态（BLOCKED）

synchronized(object){

System.out.println("thread0进入：等待唤醒状态（WAITING）");

object.wait();

System.out.println("thread0被解除完成：等待唤醒状态（WAITING）");

}

System.out.println("thread0"+Thread.currentThread().getState());

}catch(InterruptedExceptione){

e.printStackTrace();

}

});

//新创建状态（NEW）

System.out.println(thread0.getName()+"："+thread0.getState());

Threadthread1=newThread(()->{

try{

System.out.println("thread1 进入：计时等待状态（TIMED_WAITING）");

Thread.sleep(2);

System.out.println("thread1 出来：计时等待状态（TIMED_WAITING）");

}catch(InterruptedExceptione){

e.printStackTrace();

}

//被阻塞状态（BLOCKED）

synchronized(object){

System.out.println("thread1 解除：等待唤醒状态（WAITING）");

object.notify();

System.out.println("thread1 解除完成：等待唤醒状态（WAITING）");

}

System.out.println("thread1"+Thread.currentThread().getState());

});

//新创建状态（NEW）

System.out.println(thread1.getName()+"："+thread1.getState());

printState(thread0);

printState(thread1);

//可运行状态（RUNNABLE）

thread0.start();

//可运行状态（RUNNABLE）

thread1.start();

}

//使用独立线程来打印线程状态

privatestaticvoidprintState(Threadthread){

newThread(()->{

while(true){

System.out.println(thread.getName()+"："+thread.getState());

if(thread.getState().equals(Thread.State.TERMINATED)){

System.out.println(thread.getName()+"："+thread.getState());

break;

}

}

}).start();

}

}

执行结果：简化后的输出结果

Thread-0：NEWThread-1：NEWThread-0：RUNNABLEThread-1：RUNNABLEthread0 进入：等待唤醒状态（WAITING）Thread-1：BLOCKEDthread1 进入：计时等待状态（TIMED_WAITING）Thread-0：BLOCKEDThread-0：WAITING……Thread-0：WAITINGThread-1：BLOCKEDThread-1：TIMED_WAITING……Thread-1：TIMED_WAITINGThread-1：BLOCKED……Thread-1：BLOCKEDThread-0：WAITING……Thread-0：WAITINGthread1 出来：计时等待状态（TIMED_WAITING）Thread-0：WAITINGThread-1：BLOCKEDthread1 解除：等待唤醒状态（WAITING）Thread-1：BLOCKEDThread-0：WAITINGThread-0：BLOCKEDthread1 解除完成：等待唤醒状态（WAITING）Thread-1：BLOCKEDthread1 RUNNABLEThread-0：BLOCKEDThread-1：TERMINATEDthread0 被解除完成：等待唤醒状态（WAITING）Thread-0：BLOCKEDthread0 RUNNABLEThread-0：TERMINATED

最终的执行结果如图。

注意：因为案例中使用了独立线程来打印不同线程的状态，会出现状态打印稍微延迟的情况。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。