借鉴文献：
深入浅出Java多线程

注：《深入浅出Java多线程》是一本书，小编看的是它的 pdf，上面那个网页和书中内容是一致的。小编在起初学习多线程的时候是通过看视频的形式，学的模模糊糊的，这本书感觉很适合拾起逝去的知识。😎，小编观后感，推荐给大家。

Java线程的状态及主要转换方法

一、操作系统中的线程状态转换
二、Java线程的6个状态
- 1. NEW
- - 关于start()的两个引申问题
- 2. RUNNABLE
- 3. BLOCKED
- 4. WAITING
- 5. TIMED_WAITING
- 6. TERMINATED
三、线程状态的转换
- 1. BLOCKED与RUNNABLE状态的转换
- 2. WAITING状态和RUNNABLE状态的转换
- 3. TIMED_WAITING与RUNNABLE状态转换
- 4. 线程中断

一、操作系统中的线程状态转换

先了解操作系统中的线程状态转换，有助于后面理解Java线程的状态。（当时小编看视频学习的时候，介绍的状态就是下面的操作系统的线程状态🤡）

在现在的操作系统中，线程是被视为轻量级进程的，所以操作系统线程的状态其实和操作系统进程的状态是一致的。

在这里插入图片描述操作系统线程五大状态简单介绍：

新建状态（new）：线程存在但没被使用。
就绪状态（ready）：线程正在等待获取CPU时间片。
执行状态（running）：线程获取到了CPU时间片，正在使用CPU。
等待状态（waiting）：线程经过等待时间的调用或者正在等待其他资源（比如I/O）
结束状态（terminated）：线程执行完成。

二、Java线程的6个状态

在 java.lang.Thread 类中有个状态枚举类如下

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

下面对六大状态进行介绍

1. NEW

处于 NEW 状态的线程此时尚未启动。这里的尚且启动指的是还没调用Thread实例的start()方法。

	@Test
    public void testThreadStateNew(){
        Thread thread = new Thread(()->{});
        System.out.println(thread.getState());// NEW
    }

从上面可以看出，只是创建了线程而并没有调用start()方法去开启一个线程，此时线程处于NEW状态。

看看 java.lang.Thread.getState() 源码：

	public State getState() {
        // get current thread state 获得当前线程的状态
        return jdk.internal.misc.VM.toThreadState(threadStatus);
        // threadStatus用来判断线程状态的工具，默认是0，就是没开始，新建状态
    }
	// 下面这些数字是由16进制的静态常量属性转换而来的
	public static Thread.State toThreadState(int threadStatus) {
        if ((threadStatus & 4) != 0) {
            return RUNNABLE;
        } else if ((threadStatus & 1024) != 0) {
            return BLOCKED;
        } else if ((threadStatus & 16) != 0) {
            return WAITING;
        } else if ((threadStatus & 32) != 0) {
            return TIMED_WAITING;
        } else if ((threadStatus & 2) != 0) {
            return TERMINATED;
        } else if ((threadStatus & 1) == 0) {
            return NEW;
        } else {
            return RUNNABLE;
        }
    }

关于start()的两个引申问题

反复调用同一个线程的start()方法是否可行？
假如一个线程执行完毕（此时处于TERMINATED状态），再次调用这个线程的start()方法是否可行？

分析这两个问题，下面看看start()源码

	/*
     * Java thread status for tools, default indicates thread 'not yet started'
     */
     // 就是说它是用来判断线程状态的工具，默认是0，是没开始，新建状态
    private volatile int threadStatus;
	
	public synchronized void start() {
			// 就是如果threadStatus状态不是0，就抛出异常，就不能执行
        if (threadStatus != 0)
            throw new IllegalThreadStateException();

        group.add(this);

        boolean started = false;// 这变量用来定义线程是否已经执行完成，也就是是否顺利
        try {
            start0();// 一个本地方法，俺看不见
            
            started = true;// 如果start0()进行的不顺利，
            // 抛出异常后这行代码不执行，在finally中交给线程组管理
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {
                
            }
        }
    }

那个 start0() 本地方法小编看不见，据书中所说，start0() 这个方法里面并没有对 threadStatus 属性进行处理。那从上下文看来就没有对 threadStatus 这个属性进行重新赋值为0.

接下来看看调试结果

    @Test
    public void testThreadStateNew(){
        Thread thread = new Thread(()->{});
        thread.start();
        thread.start();
    }

进入第一个start后，threadStatus的值是0：

在这里插入图片描述 start0()方法结束后，threadStatus的值变成了5，根据上面对 getStatus方法的源码分析可以得到，这时的状态的是 RUNNABLE。

在这里插入图片描述
第二次thread线程对象调用start()会抛出异常。

在这里插入图片描述在调式的过程中，threadStatus 会变化多次。

中上所述总结：

上面两个引申问题都是不可行的，在调用一次start() 之后，threadStatus的值会发生改变，在调用start方法会抛出异常。调式时第二次进入start方法中threadStatus是2，对应的状态是TERMINATED。

2. RUNNABLE

源码中对RUNNABLE中的定义：

表示当前线程正在运行当中，处于RUNNABLE状态的线程在Java虚拟机中，也有可能在等待CPU分配资源。

Java线程的RUNNABLE状态其实是包括了传统操作系统线程的ready和running两个状态的。

3. BLOCKED

阻塞状态。处于BLOCKED状态的线程正等待锁的释放以进入同步区。

下面是书中给的生活小例子：

假如今天你下班后准备去食堂吃饭。你来到食堂仅有的一个窗口，发现前面已经有个人在窗口前了，此时你必须得等前面的人从窗口离开才行。

假设你是线程t2，你前面的那个人是线程t1。此时t1占有了锁（食堂唯一的窗口），t2正在等待锁的释放，所以此时t2就处于BLOCKED状态。

4. WAITING

等待状态。处于等待状态的线程变成RUNNABLE状态需要其他线程唤醒。

调用如下三个方法会使得线程进入等待状态：

Object.wait():使得当前线程处于等待状态直到另一个线程唤醒它；
Thread.join():等待线程执行完毕，底层调用的是Object实例的wait方法；
LockSupport.park():除非获得调用许可，否则禁用当前线程进行线程调度。

借用书中的例子，（总感觉书中例子有点牵强）：

你等了好几分钟现在终于轮到你了，突然你们有一个“不懂事”的经理突然来了。
你看到他你就有一种不祥的预感，果然，他是来找你的。
他把你拉到一旁叫你待会儿再吃饭，说他下午要去作报告，赶紧来找你了解一下项目的情况。
你心里虽然有一万个不愿意但是你还是从食堂窗口走开了。
此时，假设你还是线程t2，你的经理是线程t1。
虽然你此时都占有锁（窗口）了，“不速之客”来了你还是得释放掉锁。
此时你t2的状态就是WAITING。然后经理t1获得锁，进入RUNNABLE状态。
要是经理t1不主动唤醒你t2（notify、notifyAll..），可以说你t2只能一直等待了。

5. TIMED_WAITING

超时等待状态。线程等待一个具体的时间，时间到了后会被自动唤醒。
调用如下方法会使得线程进入超时等待状态：

Thread.sleep(long millis)：使当前线程睡眠指定时间；
Object.wait(long timeout)：线程休眠指定时间，等待期间可以通过notify()/notifyAll()唤醒；
Thread.join(long millis)：等待当前线程最多执行millis毫秒，如果millis为0，则会一直执行；
LockSupport.parkNanos(long nanos)：除非获得调用许可，否则禁用当前线程进行线程调度指定时间；
LockSupport.parkUntil(long deadline)：同上，也是禁止线程进行调度指定时间；

还是借用书中延续的例子，但这次的解释的不错：

到了第二天中午，又到了饭点，你还是到了窗口前。突然间想起你的同事叫你等他一起，他说让你等他十分钟他改个bug。
好吧，你说那你就等等吧，你就离开了窗口。很快十分钟过去了，你见他还没来，你想都等了这么久了还不来，那你还是先去吃饭好了。
这时你还是线程t1，你改bug的同事是线程t2。t2让t1等待了指定时间，此时t1等待期间就属于TIMED_WATING状态。
t1等待10分钟后，就自动唤醒，拥有了去争夺锁的资格。

6. TERMINATED

终止状态。此时线程已执行完毕。

三、线程状态的转换

根据上面关于各个线程状态的介绍，可以得出下面的线程状态转换图：

在这里插入图片描述

1. BLOCKED与RUNNABLE状态的转换

其实这俩状态之间的转换就是线程同步执行的时候会发生，也就是抢占锁的时候。具体可以看看Java线程安全这篇博客。

2. WAITING状态和RUNNABLE状态的转换

下面解释一下使用Object.wait()和Thread.join()使线程由WAITING状态转换成RUNNABLE状态。

Object.wait():调用wait()方法前必须持有对象的锁，调用wait()方法后，会释放当前的锁，直到有其他线程调用notify()/notfyall()方法唤醒等待锁的线程。需要注意的是，其他线程调用notify()方法只会唤醒单个等待锁的线程，如有多个线程都在等待这个锁的话不一定会唤醒到之前调用wait()方法的线程。同样，调用notifyAll()方法唤醒所有等待锁的线程之后，也不一定会马上把时间片分给刚才放弃锁的那个线程，具体要看系统的调度。
Thread.join()：调用 join() 方法不会释放锁，会一直等待当前线程执行完毕（转换为TERMINATED状态）。

    @Test
    public void testJoin() throws InterruptedException {
        Thread thread = new Thread(()->{
            try {
                Thread.sleep(1000*5);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(Thread.currentThread().getName()+"正在执行");
        });
        thread.start();
        thread.join();
        System.out.println(thread.getName() + ":" + thread.getState());
        //Thread-0正在执行
        //Thread-0:TERMINATED
    }

上面thread.join()执行完之后，main线程并没有继续执行下去，而是等待thread线程执行完成后，再执行，所以输出结果如上面注释所示。

3. TIMED_WAITING与RUNNABLE状态转换

TIMED_WAITING与WAITING状态类似，只是TIMED_WAITING状态等待的时间是指定的。

Thread.sleep(long)==》不会释放锁

使当前线程睡眠指定时间。
需要注意这里的“睡眠”只是暂时使线程停止执行，并不会释放锁。
时间到后，线程会重新进入RUNNABLE状态。

Object.wait(long)

wait(long)方法使线程进入TIMED_WAITING状态。
这里的wait(long)方法与无参方法wait()相同的地方是，都可以通过其他线程调用notify()或notifyAll()方法来唤醒。
不同的地方是，有参方法wait(long)就算其他线程不来唤醒它，经过指定时间long之后它会自动唤醒，拥有去争夺锁的资格。

Thread.join(long)==》不会释放锁

join(long)使当前线程执行指定时间，并且使线程进入TIMED_WAITING状态。

4. 线程中断

下面是Thread类中提供的几个中断线程的方法：

Thread.interrupt()：中断线程。这里的中断线程并不会立即停止线程，而是设置线程的中断状态为true（默认是flase）；
Thread.currentThread().isInterrupted()：测试当前线程是否被中断。线程的中断状态受这个方法的影响，意思是调用一次使线程中断状态设置为true，连续调用两次会使得这个线程的中断状态重新转为false；
Thread.isInterrupted()：测试当前线程是否被中断。与上面方法不同的是调用这个方法并不会影响线程的中断状态。