面试题：说说Java线程的状态及转换

ゝ一纸荒年。 2024-02-24 02:33 8阅读 0赞

#### 文章目录 ####

*  为何要了解Java线程状态
 *  Java线程状态转换图
 *  Java线程有哪些状态？
 *  关于wait()放在while循环的疑问
 *  BLOCKED 和 WAITING 状态的区别和联系

--------------------

## 为何要了解Java线程状态 ##

线程是 JVM 执行任务的最小单元，理解线程的状态转换是理解后续多线程问题的基础。

## Java线程状态转换图 ##

![在这里插入图片描述][22c44a7ff9894b8dbcab5ac225279597.png]

## Java线程有哪些状态？ ##

在 JVM 运行中，线程一共有 NEW、RUNNABLE、BLOCKED、WAITING、TIMED\_WAITING、TERMINATED 六种状态，这些状态对应 Thread.State 枚举类中的状态。

**Thread.State枚举源码：**

为方便阅读，在此去掉了文档注释

public enum State {
        
     NEW,
     RUNNABLE,
     BLOCKED,
     WAITING,
     TIMED_WAITING,
     TERMINATED;
    }

在给定的时间点，线程只能处于这些状态中的一种状态。这些状态是不反映任何操作系统线程状态的虚拟机状态。

**NEW,TERMINATED**

这两个状态比较好理解，当创建一个线程后，还没有调用start()方法时，线程处在 NEW 状态，线程完成执行，退出后变为TERMINATED终止状态。

**RUNNABLE**

运行 Thread 的 start 方法后，线程进入 RUNNABLE 可运行状态

/**
     * 程序目的：观察线程的各种状态
     */
    class MyThread extends Thread {
        
     @Override
     public void run() {
        
      System.out.printf("%s线程运行\n", Thread.currentThread().getName());
     }
    }
    
    /**
     * 分别观察创建线程后、start()后、和线程退出后的线程状态。
     * 其中Thread.sleep(50);是为了等待线程执行完
     */
    public class ThreadStateDemo {
        
     public static void main(String[] args) throws InterruptedException {
        
      MyThread myThread = new MyThread();
      System.out.printf("创建线程后，线程的状态为：%s\n", myThread.getState());
      myThread.start();
      System.out.printf("调用start()方法后线程的状态为：%s\n", myThread.getState());
      // 休眠50毫秒，等待MyThread线程执行完
      Thread.sleep(50);
      System.out.printf("再次打印线程的状态为：%s\n", myThread.getState());
    
     }
    }

输出结果：

创建线程后，线程的状态为：NEW
    调用start()方法后线程的状态为：RUNNABLE
    Thread-0线程运行
    再次打印线程的状态为：TERMINATED

我们可以看到，输出结果符合预期。

*  在刚创建完线程后，状态为NEW
 *  调用了start()方法后线程的状态变为：RUNNABLE。
 *  然后，我们看到了run()方法的执行，这个执行，是在主线程main打印了调用start()方法后线程的状态为：RUNNABLE输出后执行的。
 *  随后，我们让main线程休眠了50毫秒，等待MyThread线程退出
 *  最后再打印MyThread线程的状态，为TERMINATED。

**BLOCKED**

如图左侧所示，在运行态中的线程进入 synchronized 同步块或者同步方法时，如果获取锁失败，则会进入到 BLOCKED 状态。当获取到锁后，会从 BLOCKED 状态恢复到就绪状态。

import lombok.extern.slf4j.Slf4j;
    
    /**
     * 程序目的：观察线程的BLOCKED状态
     */
    @Slf4j
    public class ThreadBlockedStateDemo {
        
    
     public static void main(String[] args) {
        
      Thread threadA = new Thread(() -> method01(), "A-Thread");
      Thread threadB = new Thread(() -> method01(), "B-Thread");
    
      threadA.start();
      threadB.start();
    
      log.info("线程A的状态为：{}", threadA.getState());
      log.info("线程B的状态为：{}", threadB.getState());
     }
    
     /**
      * 停顿10毫秒、模拟方法执行耗时
      */
     public static synchronized void method01() {
        
      log.info("[{}]:开始执行主线程的方法", Thread.currentThread().getName());
      try {
        
       Thread.sleep(10);
      }
      catch (InterruptedException e) {
        
       e.printStackTrace();
      }
      log.info("[{}]:主线程的方法执行完毕", Thread.currentThread().getName());
     }
    }

输出结果：

2020-06-26 20:32:15.404 [A-Thread] INFO  com.hua.threadtest.state.ThreadBlockedStateDemo - [A-Thread]:开始执行主线程的方法
    2020-06-26 20:32:15.404 [main    ] INFO  com.hua.threadtest.state.ThreadBlockedStateDemo - 线程A的状态为：RUNNABLE
    2020-06-26 20:32:15.407 [main    ] INFO  com.hua.threadtest.state.ThreadBlockedStateDemo - 线程B的状态为：BLOCKED
    2020-06-26 20:32:15.417 [A-Thread] INFO  com.hua.threadtest.state.ThreadBlockedStateDemo - [A-Thread]:主线程的方法执行完毕
    2020-06-26 20:32:15.418 [B-Thread] INFO  com.hua.threadtest.state.ThreadBlockedStateDemo - [B-Thread]:开始执行主线程的方法
    2020-06-26 20:32:15.430 [B-Thread] INFO  com.hua.threadtest.state.ThreadBlockedStateDemo - [B-Thread]:主线程的方法执行完毕

A线程优先获得到了锁，状态为RUNNABLE,这时，B线程处于BLOCKED状态。

当A线程执行完毕后，B线程执行对应方法。

**WAITING,TIMED\_WAITING**

如图右侧所示，运行中的线程还会进入等待状态，这两个等待一个是有超时时间的等待，例如调用 Object.wait、Thread.join 等；另外一个是无超时的等待，例如调用 Thread.join 或者 Locksupport.park等。这两种等待都可以通过 notify 或 unpark 结束等待状态并恢复到就绪状态。

官方文档说明为：

> A thread in the waiting state is waiting for another thread to perform a particular action. For example, a thread that has called Object.wait() on an object is waiting for another thread to call Object.notify() or Object.notifyAll() on that object. A thread that has called Thread.join() is waiting for a specified thread to terminate.

处于等待状态的线程正在等待另一个线程执行特定的操作。

接下来我们来模拟一下线程的WAITING状态：

import lombok.extern.slf4j.Slf4j;
    
    /**
     * <pre>
     * 程序目的：观察线程的WAITING状态
     * 模拟：只有一个售票窗口的售票厅，有两个粉丝都想买票。
     * 如果没有票，他们就继续等待、如果有票，则买票、然后离开售票厅。
     * 其中，工作人员会补票，补票之后，粉丝就可以买到票了。
     * </pre>
     */
    @Slf4j
    public class ThreadWaitingStateDemo {
        
    
     public static void main(String[] args) throws InterruptedException {
        
      Ticket ticket = new Ticket();
      Thread threadA = new Thread(() -> {
        
       synchronized (ticket) {
        
    
        while (ticket.getNum() == 0) {
        
         try {
        
          ticket.wait();
         }
         catch (InterruptedException e) {
        
          e.printStackTrace();
         }
        }
        ticket.buy();
       }
      }, "粉丝A");
    
      Thread threadB = new Thread(() -> {
        
       synchronized (ticket) {
        
        while (ticket.getNum() == 0) {
        
         try {
        
          ticket.wait();
         }
         catch (InterruptedException e) {
        
          e.printStackTrace();
         }
        }
        ticket.buy();
       }
      }, "粉丝B");
    
      threadA.start();
      threadB.start();
    
      // 确保A和B线程都运行起来
      Thread.sleep(10);
      log.info("粉丝A线程的状态为：{}", threadA.getState());
      log.info("粉丝B线程的状态为：{}", threadB.getState());
    
      Thread employeeThread = new Thread(() -> {
        
       synchronized (ticket) {
        
        if (ticket.getNum() == 0) {
        
         ticket.addTickt();
         ticket.notifyAll();
        }
       }
      }, "补票员");
      employeeThread.start();
     }
    
    }
    
    @Slf4j
    class Ticket {
        
    
     /**
      * 票的张数
      */
     private int num = 0;
    
     public int getNum() {
        
      return num;
     }
    
     public void addTickt() {
        
      try {
        
       Thread.sleep(2_000);
      }
      catch (InterruptedException e) {
        
       e.printStackTrace();
      }
      log.info("补充票");
      this.num += 2;
     }
    
     /**
      * 停顿10毫秒、模拟方法执行耗时
      */
     public void buy() {
        
      log.info("[{}]:购买了一张票", Thread.currentThread().getName());
      log.info("[{}]:退出售票厅", Thread.currentThread().getName());
     }
    }

输出：

2020-06-26 21:26:37.938 [main    ] INFO  com.hua.threadtest.state.ThreadWaitingStateDemo - 粉丝A线程的状态为：WAITING
    2020-06-26 21:26:37.945 [main    ] INFO  com.hua.threadtest.state.ThreadWaitingStateDemo - 粉丝B线程的状态为：WAITING
    2020-06-26 21:26:39.948 [补票员     ] INFO  com.hua.threadtest.state.Ticket - 补充票
    2020-06-26 21:26:39.949 [粉丝B     ] INFO  com.hua.threadtest.state.Ticket - [粉丝B]:购买了一张票
    2020-06-26 21:26:39.949 [粉丝B     ] INFO  com.hua.threadtest.state.Ticket - [粉丝B]:退出售票厅
    2020-06-26 21:26:39.949 [粉丝A     ] INFO  com.hua.threadtest.state.Ticket - [粉丝A]:购买了一张票
    2020-06-26 21:26:39.949 [粉丝A     ] INFO  com.hua.threadtest.state.Ticket - [粉丝A]:退出售票厅

当修改ticket.wait();为ticket.wait(10);后，输出结果如下：

2020-06-26 21:27:10.704 [main    ] INFO  com.hua.threadtest.state.ThreadWaitingStateDemo - 粉丝A线程的状态为：TIMED_WAITING
    2020-06-26 21:27:10.709 [main    ] INFO  com.hua.threadtest.state.ThreadWaitingStateDemo - 粉丝B线程的状态为：TIMED_WAITING
    2020-06-26 21:27:12.714 [补票员     ] INFO  com.hua.threadtest.state.Ticket - 补充票
    2020-06-26 21:27:12.714 [粉丝B     ] INFO  com.hua.threadtest.state.Ticket - [粉丝B]:购买了一张票
    2020-06-26 21:27:12.714 [粉丝B     ] INFO  com.hua.threadtest.state.Ticket - [粉丝B]:退出售票厅
    2020-06-26 21:27:12.715 [粉丝A     ] INFO  com.hua.threadtest.state.Ticket - [粉丝A]:购买了一张票
    2020-06-26 21:27:12.715 [粉丝A     ] INFO  com.hua.threadtest.state.Ticket - [粉丝A]:退出售票厅

## 关于wait()放在while循环的疑问 ##

为什么ticket.wait();要放在while (ticket.getNum() == 0)代码块中呢？既然这行代码时让线程等待着，那使用if不就行了？

我们设想一下，如果使用if，则在线程被唤醒后，会继续往下执行，不再判断条件是否符合，这时还是没有票，粉丝也就购买不到票了。

我们看一下Object.wait()的官方doc说明：

As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:
               synchronized (obj) {
        
                   while (<condition does not hold>)
                       obj.wait();
                   ... // Perform action appropriate to condition
               }

在一个参数版本中(wait方法)，中断和虚假的唤醒是可能的，这个方法应该总是在循环中使用。

我们再继续看Object.wait(long timeout)的文档说明：

> A thread can also wake up without being notified, interrupted, or  
> timing out, a so-called spurious wakeup. While this will rarely occur  
> in practice, applications must guard against it by testing for the  
> condition that should have caused the thread to be awakened, and  
> continuing to wait if the condition is not satisfied. In other words,  
> waits should always occur in loops

线程也可以在没有通知、中断或超时的情况下被唤醒，这就是所谓的假唤醒。虽然这种情况在实践中很少发生，但应用程序必须通过测试导致线程被唤醒的条件来防止这种情况发生，如果条件不满足，则继续等待。换句话说，等待应该总是在循环中发生

所以，为了避免很少发生的假唤醒出现时程序发生不可预知的错误，建议把wait()调用放在循环语句中。这样就算被假唤醒，也有条件语句的限制。

这也是为何wait要放在循环语句中的一个原因。

## BLOCKED 和 WAITING 状态的区别和联系 ##

表：处于等待状态的各种细分状态对比

![在这里插入图片描述][d863be40ca7b4f66b9ffeefe44ca2ab5.png]

简单来说，处于BLOCKED状态的线程，还是在竞争锁的，一旦cpu有时间，它竞争到了锁、就会执行。

但是WAITING状态的线程则不去竞争锁，需要等待被动通知、或者自己定的闹钟（等待时间）到了、再去竞争锁。

一图胜千言，在此引用一张国外一位大牛画的图：

![图：线程转换-详细][-]

[22c44a7ff9894b8dbcab5ac225279597.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/24/de0a47696fca496f9eac5503bac40ccf.png
[d863be40ca7b4f66b9ffeefe44ca2ab5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/24/3c2022a1b331473da9b8fc47aa101194.png
[-]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/24/b920a80424e24753933122f10bebbeac.png