面试题：线程有几种状态

JAVA虚拟机中的线程状态

可以通过Thread.State来查看

NEW

线程刚创建时默认是这个状态，比如new Thread();

RUNNABLE

执行start方法后，线程的状态是RUNNABLE.

BLOCKED

等待获取锁的线程处于该状态。

WAITING

等待其他线程处理结束，如CountDownLatch.await方法会让当前线程处于WAITING状态。

TIMED_WAITING

在线程中执行sleep语句时，线程的状态是TIMED_WAITING

TERMINATED

线程执行完毕，会是这种状态

代码示例

import org.junit.jupiter.api.Test;
​
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
​
import static org.junit.jupiter.api.Assertions.assertEquals;
​
public class ThreadTest {
    private static final Object lockObj = new Object();
​
    Thread thead0 = null;
    Thread thead1 = null;
    int threadFlag0 = -1; // -1:初始状态，1:开始状态，2:已结束
    int threadFlag1 = -1;
​
    @Test
    void testTheadStatus() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(2);
​
        thead0 = new Thread(()->{
            synchronized (lockObj){
                threadFlag0 = 1;
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(threadFlag1>0){
                    if(thead1!=null){
                        System.out.println("thread-1 status:" + thead1.getState());
                        if(threadFlag1==1){
                            // 如果threadFlag1=1说明thread1已经开始执行，但synchronized是个互斥锁，thread1肯定在锁池里等待获取锁
                            assertEquals(Thread.State.BLOCKED,thead1.getState());
                        }else{
                            assertEquals(Thread.State.TERMINATED,thead1.getState());
                        }
                    }
                }else if(thead1!=null){
                    System.out.println("thread-1 status:" + thead1.getState());
                }
                System.out.println("thread 0 ...");
                // 执行完毕
                threadFlag0 = 2;
                lockObj.notify();
            }
            latch.countDown();
        });
        // 线程通过new方式创建之后，默认是状态是NEW
        assertEquals(Thread.State.NEW,thead0.getState());
        thead0.start();
        // start之后，状态是RUNNABLE
        assertEquals(Thread.State.RUNNABLE,thead0.getState());
​
        thead1 = new Thread(()->{
            synchronized (lockObj){
                threadFlag1 = 1;
                if(threadFlag0>0){
                    if(thead0!=null){
                        System.out.println("thread-0 status:" + thead0.getState());
                        if(threadFlag0==1){
                            assertEquals(Thread.State.BLOCKED,thead0.getState());
                        }else{
                            // threadFlag0是2的话，thread0肯定已经执行完毕，所以是TERMINATE状态
                            assertEquals(Thread.State.TERMINATED,thead0.getState());
                        }
                    }
                }else{
                    System.out.println("thread-0 status:" + thead0.getState());
                }
                try {
                    if(threadFlag0<0){
                        lockObj.notify();
                        lockObj.wait();
                    }
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("thread 1 ...");
                threadFlag1 = 2;
            }
            latch.countDown();
        });
        thead1.start();
​
        Thread mainThread = Thread.currentThread();
        new Thread(()->{
            while (true){
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 当latch.await()阻塞时，当前主线程的状态是WAITING
                System.out.println("thread3 thead-main status:"+mainThread.getState());
                // 在线程中执行sleep语句时，线程的状态是TIMED_WAITING
                System.out.println("thread3 thead-0 status:"+thead0.getState());
                System.out.println("thread3 thead-1 status:"+thead1.getState());
            }
        }).start();
​
        latch.await();
        assertEquals(Thread.State.TERMINATED,thead0.getState());
​
​
    }
​
}

JVM线程与操作系统线程状态在映射关系

参考文章

【Java多线程】了解线程的锁池和等待池概念_墩墩分墩-CSDN博客

Java线程的5种状态及切换(透彻讲解)-京东面试 - aspirant - 博客园