Java多线程之线程状态的迁移详解

一、六种状态

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

new：表示线程刚刚创建出来，还未启动

runnable：可运行状态，该状态的线程可以是ready或running，唯一的决定因素是线程调度器

blocked：阻塞，线程正在等待一个monitor锁以便进入一个同步代码块

waiting：等待，一种挂起等待的状态。一个线程处于waiting是为了等待其他线程执行某个特定的动作。

timed_waiting：定时等待。

terminated：终结，线程执行结束后的状态。

二、状态迁移图

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

线程迁移图虽然是背了忘忘了背，反反复复很多遍，但是记忆这张图其实并不困难。首先就是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 执行完后才会继续执行，说白了，就是方便程序员让线程插队用的：

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 种状态不仅要熟记，而且在什么情况下会出现这些状态也要清晰明了。

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

到此这篇关于java多线程之线程状态的迁移详解的文章就介绍到这了,更多相关java线程状态迁移内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！