1.所有线程状态（共6种）

public class ThreadState {
    public static void main(String[] args) {
        printState();
    }

    /**
     * 打印所有的线程状态
     */
    private static void printState() {
        for (Thread.State item : Thread.State.values()) {
            System.out.println(item);
        }
    }
}

查看源码：

①NEW-新建状态

当线程被创建，但是未启动（start方法）之前的状态。

②RUNNABLE-运行状态

线程正在运行时的状态。

从Java角度看，就一种RUNNABLE；

从系统级别看，分为两种：

RUNNABLE（得到时间片运行中状态）
READY（已经保存了上下文，但还未得到时间片的就绪状态）。

③BLOCKED-阻塞状态

如果遇到锁，线程就会变为阻塞状态，等待另一个线程释放锁。(谁拿到锁，就相当于谁拿到了执行的权力，但这个权力是线程能控制的)当获取到锁后，又转变为RUNNABLE-运行状态。

相当于张三，王五，刘六准备好去上厕所，但厕所门锁住了，李四在里面正上，此时张，王，刘就处于阻塞状态，得等李四出来才能上。李出来后，张，王，刘竞争去上厕所。

④WAITING-无限期等待状态

将线程休眠后，线程就变为等待状态。没有明确结束时间，一直等待下去。

⑤TIMED_WAITING-有明确结束时间等待状态

将线程休眠后，线程就变为等待状态。会等待一段时间后就不再等待了。又转变为RUNNABLE-运行状态。

⑥TERMINATED-销毁状态

当线程执行完成之后，就会变成此状态。

2.线程状态转变/线程生命周期转换

1.从 NEW 到 RUNNABLE

当创建一个线程时，也就是 new Thread 的时候，此时线程是 NEW 状态。

然而调用了线程的 start 方法之后，线程的状态就从 NEW 变成了 RUNNABLE。

2.从 RUNNABLE 到 BLOCKED

当线程中的代码排队执行 synchronized 时，线程就会从 RUNNABLE 状态变为 BLOCKED 阻塞状态。

当线程获取到 synchronized 锁之后，就会从 BLOCKED 状态转变为 RUNNABLE 状态。

3.从 RUNNABLE 到 WAITTING

线程调用 wait() 方法之后，就会从 RUNNABLE 状态变为 WAITING 无时限等待状态。

当调用了 notify/notifyAll 方法之后，线程会从 WAITING 状态变成 RUNNABLE 状态。

4.从 RUNNABLE 到 TIMED_WATTING

当调用带超时时间的等待方法时，如 sleep(xxx)，线程会从 RUNNABLE 状态变成 TIMED_WAITING 有时限状态。

当超过了超时时间之后，线程就会从 TIMED_WAITING 状态变成 RUNNABLE 状态。

5.RUNNABLE 到 TERMINATED

线程执行完之后，就会从 RUNNABLE 状态变成 TERMINATED 销毁状态。

刚把李四、王五找来，还是给他们在安排任务，没让他们⾏动起来，就是 NEW 状态；
当李四、王五开始去窗⼝排队，等待服务，就进⼊到 RUNNABLE 状态。该状态并不表示已经被银⾏⼯作⼈员开始接待，排在队伍中也是属于该状态，即可被服务的状态，是否开始服务，则看调度器的调度；
当李四、王五因为⼀些事情需要去忙，例如需要填写信息、回家取证件、发呆⼀会等等时，进⼊BLOCKED、WATING、TIMED_WAITING 状态；
如果李四、王五已经忙完，为 TERMINATED 状态。

//得到当前线程的状态
Thread.currentThread().getState()

import java.util.concurrent.TimeUnit;

public class ThreadState {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            System.out.println("当前线程状态2：" + Thread.currentThread().getState());
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("当前线程状态1：" + t1.getState());
        t1.start();

        //让主线程休眠1s
        Thread.sleep(1000);
        System.out.println("当前线程状态3：" + t1.getState());

        //等待子线程执行完
        t1.join();
        System.out.println("当前线程状态4：" + t1.getState());
    }
}