Java多线程 —— 线程状态迁移

悠悠 2022-10-17 00:53 309阅读 0赞

# 引言 #

线程状态迁移，又常被称作线程的生命周期，指的是线程从创建到终结需要经历哪些状态，什么情况下会出现哪些状态。

线程的状态直接关系着并发编程的各种问题，本文就线程的状态迁移做一初步探讨，并总结在何种情况下会出现这些状态，尝试将这些状态通过一些程序模拟出来。

# 一、六种状态 #

java.lang.Thread 的状态分为以下 6 种，它们以枚举的形式，封装在了Thread类内部：

> **NEW**：表示线程刚刚创建出来，还未启动
> 
> **RUNNABLE**：可运行状态，该状态的线程可以是ready或running，唯一的决定因素是线程调度器
> 
> **BLOCKED**：阻塞，线程正在等待一个monitor锁以便进入一个同步代码块
> 
> **WAITING**：等待，一种挂起等待的状态。一个线程处于waiting是为了等待其他线程执行某个特定的动作。
> 
> **TIMED\_WAITING**：定时等待。
> 
> **TERMINATED**：终结，线程执行结束后的状态。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDUwNjk_size_16_color_FFFFFF_t_70][]

# 二、状态迁移图 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDUwNjk_size_16_color_FFFFFF_t_70 1][]

线程迁移图网上有很多，这是我自己参考着绘制的一张。

线程迁移图虽然是背了忘忘了背，反反复复很多遍，但是记忆这张图其实并不困难。首先就是NEW和TERMINATED状态，一个表示刚刚创建，一个表示任务结束。

最重要的是记住WAITING和BLOCKED这两种状态与RUNNABLE相互切换的条件。

BLOCKED状态在Java doc中的描述是“等待一个monitor锁”，monitor对象是与对象实例相关联的一个锁对象，这个锁对象实际上就是 synchronized 的具体实现，一般称之为重量级锁，进入同步代码块的过程，实际上就是获取到 monitor 对象的锁的过程。如果锁被其他线程占用，当前线程就变成了BLOCKED状态，如果得到了锁，就由BLOCKED切换到RUNNABLE状态。

WAITING 是一种挂起状态，处于 waiting 的线程表示它正在等待一个有缘人~ 这个有缘人需要执行特定的动作才能解救 waiting 中的线程。就像孙悟空在五指山下等了五百年，只有玄奘摘下山顶的符咒才能够破土而出。

导致 WAITING 的情况只有三种：

> wait()
> 
> join()
> 
> LockSupport.park()

wait() 方法是 Object 的成员方法，它可以令当前线程针对于某个对象挂起等待，并释放获得的锁资源，只有当其他线程调用这个对象的notify()或 notifyAll() 方法，才能够唤醒等待中的线程。注意，notify()或 notifyAll() 不会释放锁资源。

join() 方法是线程的一个成员方法，“加入一个线程”，这好像合情合理，比如 t1线程在执行的过程中调用了 t2.join()，那么好吧， t1就会由 RUNNABLE 变为 WAITING，因为他要等待 t2 执行完后才会继续执行，说白了，就是方便程序员让线程插队用的：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDUwNjk_size_16_color_FFFFFF_t_70 2][]

LockSupport.park()更方便，它是一个静态方法，可以让线程在调用的位置直接WAITING，然后在其他线程中，获取到WAITING中的线程对象，传入LockSupport(thread) 直接恢复运行。

# 三、线程状态模拟 #

准备三个线程 monitor 监视线程，主要实时监视 t1线程的状态；

t1 线程模拟各种状态，t2 辅助 t1 模拟各种状态：

public class ThreadState {
        static Object lock = new Object();
        
        // 模拟 NEW、RUNNABLE、WAITING、TIMED_WAITING、BLOCKED、TERMINATED
        public static void main(String[] args) {
            ThreadState thisObj = new ThreadState();
            Thread t1 = new Thread(() -> {
                try {
                    // 先获取 t2 对象
                    Thread t2 = getThreadByName("t2");
                    // 先执行一套逻辑，推迟同步代码块的调用
                    String str = "";
                    for (int i = 0; i < 10000; i++) {
                        str += i;
                    }
                    // 调用同步代码块
                    thisObj.doSync();
                    // t2准备插队
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, "t1");
            System.out.println("t1 刚创建：" + t1.getState());
            
            Thread t2 = new Thread(() -> {
                try {
                    // 直接获取同步锁
                    thisObj.doSync();
                    // 释放锁后在运行一段时间
                    TimeUnit.SECONDS.sleep(30);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, "t2");
            
            Thread monitor = new Thread(() -> {
                Thread.State t1State = null;
                while (true) {
                    if (!t1.getState().equals(t1State)) {
                        t1State = t1.getState();
                        System.out.println("t1 此刻状态：" + t1.getState());
                    }
                    if (t1State.equals(Thread.State.TERMINATED))
                        break;
                }
            }, "monitor");
            
            monitor.start();
            t2.start();
            t1.start();
        }
        
        public synchronized void doSync() {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            String str = "";
            for (int i = 0; i < 100000; i++) {
                str += i;
            }
        }
        
        public static Thread getThreadByName(String name) {
            Optional<Thread> first = Thread.getAllStackTraces()
                    .keySet()
                    .stream()
                    .filter(thread -> thread.getName().equals(name))
                    .findFirst();
            return first.get();
        }
    }

输出：

t1 刚创建：NEW
    t1 此刻状态：RUNNABLE
    t1 此刻状态：BLOCKED
    t1 此刻状态：TIMED_WAITING
    t1 此刻状态：TIMED_WAITING
    t1 此刻状态：RUNNABLE
    t1 此刻状态：WAITING
    t1 此刻状态：BLOCKED
    t1 此刻状态：TERMINATED

# 总结 #

线程状态迁移是非常重要的多线程基础知识，在调试多线程问题的时候，能够发挥很大的作用。

6 种状态不仅要熟记，而且在什么情况下会出现这些状态也要清晰明了。

如果条件允许，可以试着通过不同的方法来模拟线程的六种状态的切换，可以加深对线程生命周期的理解。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDUwNjk_size_16_color_FFFFFF_t_70]: /images/20221014/d6932a470d4642e6957b6dc3fe84a883.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDUwNjk_size_16_color_FFFFFF_t_70 1]: /images/20221014/1e381154c5cb4fdbb3f34b52ebea0d56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ3NDUwNjk_size_16_color_FFFFFF_t_70 2]: /images/20221014/e754bab250a840d78233576e924a3f09.png