Java的6种线程状态以及线程状态的转换

详细介绍了Java线程的6中状态，以及状态之间的转换。

本文基于JDK1.8。

1 线程状态(生命周期)

1.1 源码中的状态

关于Java线程的状态，网上说法很多，有五种、六种甚至七种，本文采用Java官方的线程状态分类。

实际上，官方一共给出了六种线程状态，我们来看看源码便可知：

    public class Thread implements Runnable {
        //线程的状态以枚举的方式定义在Thread类的内部
        /**
         * A thread state.  A thread can be in one of the following states:
         * 

         * 
{@link #NEW}

         *     A thread that has not yet started is in this state.
         *     
         * 
{@link #RUNNABLE}

         *     A thread executing in the Java virtual machine is in this state.
         *     
         * 
{@link #BLOCKED}

         *     A thread that is blocked waiting for a monitor lock
         *     is in this state.
         *     
         * 
{@link #WAITING}

         *     A thread that is waiting indefinitely for another thread to
         *     perform a particular action is in this state.
         *     
         * 
{@link #TIMED_WAITING}

         *     A thread that is waiting for another thread to perform an action
         *     for up to a specified waiting time is in this state.
         *     
         * 
{@link #TERMINATED}

         *     A thread that has exited is in this state.
         *     
         * 
         *
         * 

         * A thread can be in only one state at a given point in time.
         * These states are virtual machine states which do not reflect
         * any operating system thread states.
         *
         * @since   1.5
         * @see #getState
         */
        public enum State {
            /**
             * Thread state for a thread which has not yet started.
             */
            NEW,

            /**
             * Thread state for a runnable thread.  A thread in the runnable
             * state is executing in the Java virtual machine but it may
             * be waiting for other resources from the operating system
             * such as processor.
             */
            RUNNABLE,

            /**
             * Thread state for a thread blocked waiting for a monitor lock.
             * A thread in the blocked state is waiting for a monitor lock
             * to enter a synchronized block/method or
             * reenter a synchronized block/method after calling
             * {@link Object#wait() Object.wait}.
             */
            BLOCKED,

            /**
             * Thread state for a waiting thread.
             * A thread is in the waiting state due to calling one of the
             * following methods:
             * 

             *   
{@link Object#wait() Object.wait} with no timeout
             *   
{@link #join() Thread.join} with no timeout
             *   
{@link LockSupport#park() LockSupport.park}
             * 
             *
             * 
A thread in the waiting state is waiting for another thread to
             * perform a particular action.
             * 

             * For example, a thread that has called Object.wait()
             * on an object is waiting for another thread to call
             * Object.notify() or Object.notifyAll() on
             * that object. A thread that has called Thread.join()
             * is waiting for a specified thread to terminate.
             */
            WAITING,

            /**
             * Thread state for a waiting thread with a specified waiting time.
             * A thread is in the timed waiting state due to calling one of
             * the following methods with a specified positive waiting time:
             * 

             *   
{@link #sleep Thread.sleep}
             *   
{@link Object#wait(long) Object.wait} with timeout
             *   
{@link #join(long) Thread.join} with timeout
             *   
{@link LockSupport#parkNanos LockSupport.parkNanos}
             *   
{@link LockSupport#parkUntil LockSupport.parkUntil}
             * 
             */
            TIMED_WAITING,

            /**
             * Thread state for a terminated thread.
             * The thread has completed execution.
             */
            TERMINATED;
        }
    }

从源码可以看出，Java语言定义了6种线程状态，作为内部枚举保存在Thread类中。这里我建议大家采用这六种状态，当然也可以按照自己的理解来。下面来解释一下每一种状态。

1.2 状态解释

在任意一个时间点，一个线程只能有且只有其中的一种状态，这6种状态分别如下：

1. 新建（NEW）：创建后尚未启动的线程处于这种状态。
2. 运行（RUNNABLE）：调用start()方法,RUNNABLE包括了操作系统线程状态中的Running和Ready，也就是处于此状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间(该线程已经获取了除CPU资源外的其他资源，等待获取CPU 资源后才会真正处于运行状态)。

官方为什么不将这两种状态分开呢？有种可能是：线程在这Running和Ready两种状态之间的时长太短了，现代cpu采用轮询式时间片调度，大部分线程Running和Ready的时间都非常短暂，因此考虑将这两种状态合并为RUNNABLE状态。

3. 无限期等待（WAITING）：处于这种状态的线程不会被分配CPU执行时间，它们要等待被其他线程显式地唤醒。以下方法会让线程陷入无限期的等待状态：

1. 没有设置Timeout参数的Object.wait（）方法。
2. 没有设置Timeout参数的Thread.join（）方法。
3. LockSupport.park（）方法。

4. 限期等待（TIMED_WAITING）：处于这种状态的线程也不会被分配CPU执行时间，不过无须等待被其他线程显式地唤醒，在一定时间之后它们会由系统自动唤醒。以下方法会让线程进入限期等待状态：

1. Thread.sleep(long millis)方法。
2. 设置了Timeout参数的Object.wait（）方法。
3. 设置了Timeout参数的Thread.join（）方法。
4. LockSupport.parkNanos（）方法。
5. LockSupport.parkUntil（）方法。

5. 阻塞（BLOCKED）：线程被阻塞了，“阻塞状态”与“等待状态”的区别是：“阻塞状态”在等待着获取到一个排他锁，这个事件将在另外一个线程获得锁的时候可能发生，比如synchronized之外；而“等待状态”则是在获得锁之后，主动释放锁，进入等待一段时间，或者等待唤醒动作的发生。

6. 结束（TERMINATED）：已终止线程的线程状态，线程已经结束执行。

补充：
Java将操作系统中的运行和就绪两个状态合并称为运行状态。

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块（获取锁）时的状态，但是阻塞在java.concurrent包中Lock接口的线程状态却是等待状态，因为java.concurrent包中Lock接口对于阻塞的实现均使用了LockSupport类中的相关方法。

2 线程状态转换

上述6种状态在遇到特定事件发生的时候将会互相转换，它们的转换关系如下图：

上图状态的转换和方法已经很明朗了，下面重点说说几种状态转换，以及相关方法补充。

2.1 进入等待/超时等待

2.1.1 进入等待状态

1. LockSupport.park()。
2. 发生Io阻塞。
3. suspend()，方法已过时。
4. public final void wait() 释放锁
5. public final void join() 释放锁

2.1.1.1 wait方法的介绍

wait方法属于object类，wait()方法使当前线程暂停执行并释放锁，让其他线程可以进入synchronized数据块，当前线程被放入对象等待队列中。Wait()方法必须被包含在对应的synchronized语句中，无论是wait()方法还是notify()方法都需要获取目标对象的一个监视器。

当调用notify()方法后，将从对象的等待队列中移走一个任意的线程并放到锁标志等待池中，只有锁标志等待池中线程才可能够获取锁标志；如果等待队列中没有线程，则notify()不起作用。notifyAll()则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。

被唤醒的线程并不会立即执行而是尝试获得锁,执行唤醒方法的线程也并不会立即释放锁。

2.1.1.2 join方法的介绍

join方法在内部使用wait()方法进行等待，底层用wait()来实现，可以释放锁。join方法上加了synchronuzed关键字，因此使用wait没有问题。

join方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行，有些类似于同步的运行效果。在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行。如果有多个线程,除了A线程之外的其他线程正常竞争cpu和锁。

join方法中如果传入参数，则表示这样的意思：如果A线程中调用B线程的join(10)，则表示A线程会等待B线程执行10毫秒，10毫秒过后，A、B线程并行执行。需要注意的是，jdk规定，join(0)的意思不是A线程等待B线程0秒，而是A线程等待B线程无限时间，直到B线程执行完毕，即join(0)等价于join()。(其实join()中调用的是join(0))。主线程中调用join，则主线程等待， 其他多个线程之间并不需要互相等待。

join()与synchronized的区别是：join在内部调用wait()方法进行等待，而synchronized关键字使用的是"对象监视器"原理作为同步。

    /**
     * join方法
     * @throws InterruptedException
     */
    public final void join() throws InterruptedException {
        //内部调用join(long millis)方法,参数为0 ,表示无限等待
        join(0);
    }

    /**
     * 等待millis毫秒
     * @param millis
     * @throws InterruptedException
     */
    public final synchronized void join(long millis)
            throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        //millis等于0 表示无限期等待
        if (millis == 0) {
            while (isAlive()) {
                //调用wait方法
                wait(0);
            }
        } 
        //否则,限时等待
        else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                //调用wait方法
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

2.1.2 进入超时等待

1. public final void join(long millis) --超时等待 释放锁
2. LockSupport.parkNanos
3. LockSupport.parkUntil
4. wait(long timeout); --超时等待 释放锁
5. public static void sleep(long millis); —超时等待 不释放锁

2.1.2.1 sleep方法的介绍

sleep方法使当前线程（即调用该方法的线程）暂停执行一段时间，让其他线程有机会继续执行，但它并不释放对象锁。也就是说如果有synchronized同步快，其他线程仍然不能访问共享数据。注意该方法要捕捉异常。sleep会让其他所有线程都有同等的cpu争夺权力！

睡眠时被中断，则会在sleep()处抛出InterruptedException 异常。

在调用Thread.sleep(long millis）时为millis 参数传递了一个负数， 则会抛出IllegalArgumentException 异常.

2.1.2.2 LockSupport类简介

LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，当然阻塞之后肯定得有唤醒的方法。

常用方法：

方法名称	描述
void park()	阻塞当前线程，如果调用unpark(Thread)方法或被中断，才能从park()返回。
void parkNanos(long nanos)	阻塞当前线程，超时返回，阻塞时间最长不超过nanos纳秒。
void parkUntil(long deadline)	阻塞当前线程，直到deadline时间点
void unpark(Thread)	唤醒处于阻塞状态的线程

park不需要获取某个对象的锁。因为中断的时候park不会抛出InterruptedException异常，所以需要在park之后自行判断中断状态，然后做额外的处理。

2.1.2.3 过期的suspend和resume方法

suspend方法被不推荐使用。不推荐使用suspend()去挂起线程的原因，是因为suspend()在导致线程暂停的同时，并不会去释放任何锁资源。其他线程都无法访问被它占用的锁。直到对应的线程执行resume()方法后，被挂起的线程才能继续，从而其它被阻塞在这个锁的线程才可以继续执行。如果resume()操作出现在suspend()之前执行，那么线程将一直处于挂起状态，同时一直占用锁，这就容易产生死锁。

而且，对于被挂起的线程，它的线程状态居然还是RUNNABLE

        //创建子线程,在其内部调用suspend让其"阻塞"
        Thread thread = new Thread(() -> Thread.currentThread().suspend());
        thread.start();
        //主线程睡眠三秒,让子线程充分运行
        Thread.currentThread().sleep(3000);
        //获取子线程状态,发现还是RUNNABLE状态
        Thread.State state = thread.getState();
        System.out.println(state);

2.4 进入RUNNABLE状态

1. TIMED_WAITING状态结束
2. WAITING状态被唤醒
3. BLOCKED状态获得锁
4. public static void yield();
5. 线程的cpu时间片使用完毕还未执行完任务，重回就绪态，但此时不会释放锁。

2.4.1 yield方法的介绍

yield方法又称为“线程礼让”，使调用线程释放cpu执行权，让自己和其他多个线程重新争夺cpu执行权。

线程直接回到RUNNABLE状态，而不是让线程处于阻塞态，因此也有可能是当前让步的线程又进入到“运行状态”继续运行。

yield会尽量让同等级和高等级的线程具有更大的争夺权，而sleep会让所有线程都有同等的争夺权力，但它们并不是绝对的。毕竟java线程最终是调用操作系统的资源生成的，充满了不确定性。

yield方法不会释放持有已获得的锁，只是释放cpu的执行权。

如果有什么不懂或者需要交流，各位可以留言。另外，希望收藏、关注一下，我将不间断更新Java各种教程！