【JavaEE】线程状态

目录

前言

一.线程状态图

二.线程状态

1.初始状态(NEW)

 2.运行状态(RUNNING)

 3.等待状态（WAITING)

4.超时等待（TIMED_WAITING)

5.阻塞状态（BLOCKED)

 6.终止状态(TERMINATED)

 三.线程状态间的转换

四.总结 

---

前言

线程状态及其状态转换是线程生命周期中的关键部分，下面我们就来讲解六种线程状态以及其如何转换。

一.线程状态图

线程状态其实是一种枚举类型Thread.State

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

 

• NEW（初始）：创建了一个线程，但还没有通过start方法调用。可以理解为安排了工作，但还没有开始工作。
• RUNNABLE（运行）：又分为Ready（就绪状态）和Running（运行中状态）。

当线程对象被创建之后，若有线程（比如main线程）调用了该线程对象的start，那么该线程就会进入可运行线程池进行等待线程调用，获取CPU的使用权，此时就处于Ready（就绪状态），当获取到cpu使用权之后，就转变为Running（运行中状态）。

Ready可以理解为即将开始工作，而Running即正在工作中。

• BLOCKED（阻塞）：线程试图获取一个锁对象，但此时锁对象被其他线程所占有，那么线程就进入阻塞等待，当获取到锁，则进入Running状态。
• WAITING（等待）：线程处于等待状态，等待其他线程唤醒，可以通过notify或者notifyAll方法来唤醒。
• TIMED_WAITING（超时等待）：可以在指定的时间内返回。可以使用带参数的sleep或者wait。
• TERMINATED（终止）：线程执行结束。主线程和子线程互不影响，子线程并不会因为主线程结束就结束。

二.线程状态

1.初始状态(NEW)

用new关键字新建一个线程对象，这个线程就处于new状态。

public static void main(String[] args) {// 创建一个线程，该线程在执行时会暂停1000毫秒Thread t=new Thread(()->{try {Thread.sleep(1000); // 模拟线程执行的延迟} catch (InterruptedException e) {e.printStackTrace(); // 处理线程被中断的异常}});System.out.println("t的线程状态："+t.getState()); // 输出线程的当前状态}

t的线程状态：NEW

 2.运行状态(RUNNING)

分为RUNNING（运行状态）和Ready（就绪状态）.

  public static void main(String[] args) {Thread t=new Thread(()->{try {Thread.sleep(1000);}catch (InterruptedException e){e.printStackTrace();}});t.start();System.out.println("t的线程状态："+t.getState()); // 输出线程的当前状态}

t的线程状态：RUNNABLE

 3.等待状态（WAITING)

等待状态下，没有时间限制，等被notify或者notifyAll唤醒。

 public static void main(String[] args) throws InterruptedException {// 获取当前线程对象，用于后续检查线程状态Thread mainT=Thread.currentThread();// 使用lambda表达式创建一个新的线程，该线程用于展示线程的运行和状态检查Thread t=new Thread(()->{try {// 使新线程睡眠1秒，模拟耗时操作Thread.sleep(1000);}catch (InterruptedException e){// 如果线程在睡眠时被中断，打印异常信息e.printStackTrace();}// 输出线程的当前状态System.out.println("main线程状态："+mainT.getState());});// 启动新线程，使其开始执行t.start();// 主线程等待新线程完成t.join();}

main线程状态：WAITING

4.超时等待（TIMED_WAITING)

TIMED_WAITING线程在等待唤醒，但设置了时限，当到达时限，会自动唤醒线程。

 public static void main(String[] args) throws InterruptedException {// 创建一个线程，该线程执行一个lambda表达式，使线程睡眠1秒Thread t = new Thread(() -> {try {Thread.sleep(1000); // 线程睡眠1000毫秒} catch (InterruptedException e) {e.printStackTrace(); // 捕获InterruptedException异常并打印堆栈跟踪}});t.start();//让main线程休眠Thread.sleep(50);System.out.println(t.getState());}

TIMED_WAITING

5.阻塞状态（BLOCKED)

 当进入到synchronized关键字修饰的方法或者代码块时，线程处于阻塞状态。

示例：两个线程争同一个锁对象，此时会引起锁竞争，没有获取到锁的线程，会进入阻塞状态，等待拿到锁的线程将锁释放。

   public static void main(String[] args) {final Object o=new Object();Thread t=new Thread(()->{synchronized (o) {while (true) {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}});Thread tt=new Thread(()->{synchronized (o) {while (true) {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}});t.start();tt.start();System.out.println("t的线程状态："+t.getState()); // 输出线程的当前状态System.out.println("tt的线程状态："+tt.getState()); // 输出线程的当前状态}

t的线程状态：RUNNABLE
tt的线程状态：BLOCKED

 6.终止状态(TERMINATED)

当线程执行结束，就处于终止状态。

需要注意：主线程和子线程互不影响，子线程并不会因为主线程结束就结束

/*** 程序入口* @param args 命令行参数* @throws InterruptedException 如果线程被中断*/public static void main(String[] args) throws InterruptedException {// 创建一个线程，该线程将休眠1秒Thread t = new Thread(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}});// 启动线程t.start();// 等待线程结束t.join();// 输出线程的状态System.out.println(t.getState());}

TERMINATED

 三.线程状态间的转换

1.创建一个线程处于new，让其转换为running状态。可以看到线程t的状态为

NEW->RUNNING->TERMINATED

 public static void main(String[] args) throws InterruptedException {Thread t=new Thread(()->{try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}});System.out.println("t线程的状态"+t.getState());t.start();System.out.println("t线程的状态"+t.getState());t.join();System.out.println("t线程的状态"+t.getState());}

t线程的状态NEW
t线程的状态RUNNABLE
t线程的状态TERMINATED

2.将处于running的线程转换为wait 。（调用wait或者join都可）

 这里以join为例。

 public static void main(String[] args) throws InterruptedException {Thread main = Thread.currentThread();Thread t = new Thread(() -> {try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("main线程状态："+main.getState());});t.start();System.out.println("main线程状态："+main.getState());t.join();}

main线程状态：RUNNABLE
main线程状态：WAITING

wait方法：一般在synchronized修饰的代码块或者方法中使用。

调用wait会发生两件事：

（1）线程解锁“锁对象” （2）被解锁的线程会进入waiting状态。 

在使用wait方法时，需要先对线程加锁，否则会报错。因为wait会先解锁再进入等待状态。

示例:

 public static void main(String[] args) throws InterruptedException {final Object locker = new Object();Thread t1=new Thread(()->{synchronized (locker){try {locker.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}},"t1");t1.start();System.out.println("t线程的状态"+t1.getState());Thread.sleep(50);System.out.println("t线程的状态"+t1.getState());}

t线程的状态RUNNABLE
t线程的状态WAITING

 但如果我们使用wait带参数的方法，那么状态还会是WAITING吗？

  public static void main(String[] args) throws InterruptedException {final Object locker = new Object();Thread t1=new Thread(()->{synchronized (locker){try {locker.wait(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}},"t1");t1.start();System.out.println("t线程的状态"+t1.getState());Thread.sleep(50);System.out.println("t线程的状态"+t1.getState());}

t线程的状态RUNNABLE
t线程的状态TIMED_WAITING

可以看到，当我们使用带参数的wait方法时，此时t的状态转变为TIMED_WAITING。

3.若多个线程尝试获取同一个锁，那么就会引起对锁的竞争，即"锁竞争”。没用获取到线程的锁将会进入阻塞状态（BLOCKED)，等线程获取到锁，才能执行。

示例：

    /*** 主函数，演示线程间的状态变化* @param args 命令行参数* @throws InterruptedException 当线程被中断时抛出此异常*/public static void main(String[] args) throws InterruptedException {// 创建一个对象作为锁final Object locker = new Object();// 创建线程t1，使用锁对象进行同步操作Thread t1=new Thread(()->{// 使用锁进行同步控制，形成死循环synchronized (locker){while(true){;}}},"t1");// 启动线程t1t1.start();// 输出线程t1的当前状态System.out.println("t1线程的状态"+t1.getState());// 创建线程t2，也使用锁对象进行同步操作Thread t2=new Thread(()->{// 使用锁进行同步控制，但没有进行循环，所以很快释放锁synchronized (locker){;}},"t2");// 启动线程t2t2.start();// 输出线程t2的当前状态System.out.println("t2线程的状态"+t2.getState());// 主线程等待50毫秒，以观察线程t2的状态变化Thread.sleep(50);// 再次输出线程t2的当前状态，以观察其变化System.out.println("t2线程的状态"+t2.getState());}

t1线程的状态RUNNABLE
t2线程的状态RUNNABLE
t2线程的状态BLOCKED

我们可以打开jconsole进行查看。

四.总结 

 

当我们创建一个线程对象时，此时线程就处于NEW状态。

调用start方法，会让线程进行运行状态，其中又分为RUNNING（运行中状态）和Ready（就绪状态）。

若想要让RUNNABLE中的线程进入WAITING(等待状态），可以使用wait或者join方法。想唤醒WAITING中的线程，需要使用notify或者nofityAll方法来唤醒。

可以使用带参数的join、sleep和wait方法，让RUNNABLE中的线程进入限时等待（TIMED_WAITING），当达到时时限，会自动唤醒线程。

 RUNNABLE中的线程若想出发BLOCKED状态，需要触发锁竞争。

当线程中线程体的内容都执行完之后，就会进入TERMINATED(终止状态）

---

线程状态的讲解就先到这里了~

若有不足，欢迎指正~