线程的状态

目录

线程的所有状态

线程状态转义的过程

观察线程的状态

---

线程的所有状态

线程的状态是一个枚举类型 Thread.State

我们首先来看线程的状态都有哪些： 

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

运行结果： 

在 Java 中，线程有以下几种状态： 

NEW：Thread 对象创建好了，但还没有调用 start 方法在系统中创建线程
RUNNABLE：就绪状态，表示该线程正在 CPU 上执行，或准备就绪随时可以去 CPU 上执行
BLOCKED：由于锁竞争引起的阻塞
WAITING：不带时间的阻塞（死等），必须满足一定的条件，才会解除阻塞
TIMED_WAITING：指定时间的阻塞，到达一定时间之后自动解除阻塞
TERMINATED：Thread 对象仍然存在，但系统内部的线程已经执行完毕了

线程状态转义的过程

当线程刚被创建时，就处于 NEW 状态，而当调用 start 方法，就进入了 RUNNABLE 状态， run 方法执行完毕，此时就处于 TERMINATED 状态。在 run 方法执行过程中，若调用了 sleep 方法 或 带有超时时间的 join ，则进入 TIMED_WAITING 状态；若调用了 不带超时时间的 join 或 wait 方法，则进入 WAITING 状态；若发生 锁竞争，未竞争到锁，此时会等待获取锁，处于 BLOCKED 状态

在我们后续调试多线程代码时，线程的状态可以作为调试的重要依据

在学习了线程的状态之后，我们可以进一步理解 上一篇文章 中提到的 一个 Thread 对象只能 start 一次，这和线程的状态密切相关，只有处于 NEW 状态才能进行 start，因此，一个 Thread 对象只能 start 一次

观察线程的状态

观察 NEW、RUNNABLE、TERMINATED 状态

public class ThreadDemo11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        System.out.println("start 之前：" + t.getState());
        t.start();
        System.out.println("start 之后：" + t.getState());
        // 等待线程执行完
        t.join();
        System.out.println("run 方法运行完：" + t.getState());
    }
}

运行结果：

当未调用 start 方法之前， Thread 对象创建好了，但还没有调用 start 方法在系统中创建线程，因此，处于 NEW 状态

当调用 start 方法后，就进入了 RUNNABLE 状态，此时该线程正在 CPU 上执行，或准备就绪随时可以去 CPU 上执行

当 run 方法执行完毕后，就进入了 TERMINATED 状态

接下来，我们来观察 WAITING、TIMED_WAITING 状态

同样是上述代码，我们可以通过 jconsole 来观察线程的状态

在 JDK 安装位置下找到 jconsole.exe

为了方便观察，我们修改一下代码，让其运行时间更长一些：

public class ThreadDemo11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 1_000_000; i++) {
                System.out.println("thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        System.out.println("start 之前：" + t.getState());
        t.start();
        System.out.println("start 之后：" + t.getState());
        // 等待线程执行完
        t.join();
        System.out.println("run 方法运行完：" + t.getState());
    }
}

此时点击运行，然后再打开 jconsole.exe：

选择 线程，就可以看到正在运行中的线程： 

找到 t 线程（Thread-0），观察其状态： 

t 线程每打印一次就要休眠 1s，打印的速度非常快，休眠时间长，因此 t 线程大部分时间都处于 TIMED_WAITING 状态

 找到 主线程（main 线程），观察其状态：

main 线程在等待 t 线程 运行结束，因此处于 WAITING 状态

观察 BLOCKED 状态

BLOCKED是由于锁竞争引起的阻塞，因此我们需要进行加锁：

为了方便进行观察，我们对线程进行命名

public class ThreadDemo12 {
    private static Object object = new Object();
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (object) {
                for (int i = 0; i < 1_000_000; i++) {
                    System.out.println("thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        }, "t1");
        t1.start();
        
        Thread t2 = new Thread(() -> {
            synchronized (object) {
                System.out.println("t2");
            }
        }, "t2");
        t2.start();
    }
}

运行，再次打开 jconsole 观察：

同样的，由于 t1 线程每打印一次就要休眠 1s，打印的速度非常快，休眠时间长，因此 t 线程大部分时间都处于 TIMED_WAITING 状态

 t1 线程获取到了锁，并执行相关逻辑，t2 线程就只能等待获取锁，因此 t2 处于 BLOCKED 状态