线程的状态

源码中对线程状态的定义

线程的状态

//源码中对线程状态的说明
 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:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * 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:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

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

State中定义了线程的六种状态。

1、新状态：线程对象已经创建，还没有在其上调用start()方法。

2、可运行状态：线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时，线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后，也返回到可运行状态。

3、运行状态：可运行状态获取到CPU执行权限，运行状态调用yield（）进入到可运行状态（不能保证有效果）。

4、阻塞状态：线程可运行未达到运行状态，运行状态调用synchronized进入阻塞，获取同步锁之后变为可运行。阻塞状态的线程，即使调用interrupt()方法也不会改变其状态。

6、等待状态：线程可运行未达到运行状态，运行状态调用wait ，join后进入等待状态，结束后可进入可运行。当前状态的线程不会被分配CPU资源和持有锁。

6、睡眠状态：线程可运行未达到运行状态，运行状态调用sleep，wait(long) ，join(long)会进入睡眠，结束后进入可运行。当前状态的线程不会被分配CPU资源和持有锁。

7、死亡态：执行完了run()方法，程序正常结束，或者退出时所处状态。

State中只有六种状态，为什么我列举了其中呢，其实Runnable，Runnabling是一种状态，线程一旦调用start()方法，无论是否运行，状态都为Runable，注意Runable状态指示表示线程可以运行，不表示线程当下一定在运行，线程是否运行由虚拟机所在操作系统调度决定。

可以看到，线程可以从运行转台变为其他状态，但是其他状态除了可运行状态，一般无法变为运行状态，因为线程的运行与否由线程调度进程决定。

Thread的join()方法让线程B“加入”到线程A的尾部，A执行完毕之前，B不能工作，也可以利用join（long）规定等待的时间。
Thread.yield()方法暂停当前正在执行的线程对象，并执行其他线程，但由于线程调度策略的存在，可能导致没有效果。