前言：

5. 指定时间等待状态（TIMED_WAITING）

6. 完成状态（TERMINATED）

线程的六种状态

线程的状态是一个枚举类型 Thread.State，因此可以通过以下代码可以观察到线程的所有状态:

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

运行后打印:

解释线程的六个状态:

1. 新建状态（NEW）

当一个线程被创建过后，未调用 start() 方法。此时的线程就处于新建状态，在此可理解为此时的线程只是一串代码并未在操作系统中运行。

    public static void main(String[] args) {
        Thread thread = new Thread(()-> {
            System.out.println("Hello thread");
        });
        System.out.println(thread.getState());//获取线程当前状态
    }

运行后打印:

以上代码，打印了 thread 线程的状态，用到的方法为 getState()，getState() 方法是获取当前线程的状态。以下观察其他线程的状态也是用到此方法。

2. 就绪状态（RUNNABLE）

就绪状态，代表线程已经准备运行或者正在运行。一般在调用 start() 方法后，该线程就处于该状态。此时线程应当在操作系统中运行。

    public static void main(String[] args) {
        Thread thread = new Thread(()-> {
            System.out.println("Hello thread");
        });
        thread.start();//启动thread线程
        System.out.println(thread.getState());//获取thread线程的状态
    }

运行后打印:

以上代码，通过 getState() 方法获取到了 thread 线程当前状态。处于 RUNNABLE 代表线程已经准备运行或者正在运行。

3. 阻塞状态（BLOCKED）

阻塞状态一般发生在多个线程进行工作时，假如有两个线程：线程1和线程2。当通过先启动线程1后启动线程2时候。此时的线程1处于 RUNNABLE 状态，而线程2处于 BLOCKED 状态。

通俗的来讲，线程2要等线程1执行完毕，才会给线程2安排执行。比如以下代码:

    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(()-> {
            System.out.println("Hello thread1");
        });
        Thread thread2 = new Thread(()-> {
            System.out.println("Hello thread2");
        });
        thread1.start();//启动thread1线程
        thread2.start();//启动thread2线程
        System.out.println(thread1.getState());//获取thread1线程的状态
        System.out.println(thread2.getState());//获取thread2线程的状态
    }

运行后打印:

以上代码，很好的展现了两个线程的状态。我们可以想象成一个厕所，两个线程想要上这个厕所。当线程1已经进入厕所，线程2就处于阻塞状态。

4. 等待状态（WAITING）

当两个线程运行时，在线程1内设置一个死循环。并在线程2内使用 join() 方法等待线程1执行完毕。此时的线程2就处于 WAITING（无限制等待）状态。如以下代码:

public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
           while (true) {}
        });
        thread1.start();
        Thread thread2 = new Thread(() -> {
            try {
                thread1.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread2.start();
        for (int i = 0; i < 100; i++) {
            System.out.println(thread2.getState());
        }
    }

运行后打印:

通过上述代码及打印结果，我们可以观察到。thread2 除了第一次的状态为 RUNNABLE 状态外，其他所有状态都处于无限制等待状态。

解释：

thread1 线程调用了 join 方法那么 thread2 就会一直等待 thread1 线程执行完毕。

但 thread1 线程里面是一个死循环，因此无论如何 thread2 都等不到 thread1 执行完毕。

所以造成 thread2 处于无限制等待状态也就是 WAITING 状态。就好比一个人在等待一个不爱他的人。

5. 指定时间等待状态（TIMED_WAITING）

指定时间等待状态用在于线程使用 sleep() 方法时，线程就处于指定时间等待状态。直到 sleep() 方法执行完毕，线程才会被唤醒。如以下代码:

public static void main(String[] args) {
        Thread thread = new Thread(()-> {
            for (int i = 0; i < 1000; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread.start();
        for (int i = 0; i < 1000; i++) {
            System.out.println(thread.getState());
        }
    }

运行后打印：

以上代码，thread 线程内有一个1000次的循环语句，并且循环里使用了 sleep() 方法，main 线程(主线程)里面也有一个1000次的循环语句。两个循环同时进行，每循环一次就得 sleep 一次。

因此除了第一次循环时线程处于 RUNNABLE 状态，其他的999次循环，线程 thread 都处于指定时间等待状态也就是 TIMED_WAITING 状态。

所以，TIMED_WAITING 状态与使用 sleep() 方法是密切相关的。

6. 完成状态（TERMINATED）

完成状态是最容易理解的一个状态，当线程执行完毕。这个线程就死亡了，也就是完成状态。如下代码所示:

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(()-> {
            System.out.println("Hello thread");
        });
        thread.start();//启动thread线程
        thread.join();//等待thread先行完成
        System.out.println("Hello main");
        System.out.println(thread.getState());//获取thread线程的状态
    }

运行后打印: