线程的状态

在线程Thread类中，有一个枚举类State，列举了线程的六大状态

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.     * 这个状态代表线程可能处于就绪状态，当获得cpu资源时进行执行，也可能是正则执行的线程     */    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}.     * 这个状态代表在调用Object.wait()释放了对象锁，并且该线程已经被唤醒，调用了Object.notify()方法之后     */    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.     *     * 一般在调用了Object.wait()或者Thread.join方法后，当前线程会立即进入的状态，结束等待之后线程会进入runnable或者blocked状态     */    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;}

区分BLOCKED和WAITING

package thread;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;/** *  * Thread的waiting状态和blocked状态 * 在调用Object.wait()后是waiting状态 * 在调用Object.notify()后开始竞争锁之后变成Bloceked状态 *  * @author 17020044 * @see [相关类/方法]（可选） * @since [产品/模块版本] （可选） */public class WaitNotify {    private static Object monitor;    static{        monitor = new Object();    }        public static void main(String[] args) {        ExecutorService pool = Executors.newCachedThreadPool();        Thread threadA = new Thread(){            @Override            public void run(){                synchronized(monitor){                    try {                        System.out.println("before calling wait()");                        monitor.wait();                        System.out.println("after calling wait()");                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                }            }        };                Thread threadB = new Thread(){            @Override            public void run(){                synchronized (monitor) {                    try {                        System.out.println("before calling notify");                        monitor.notify();                        Thread.sleep(30000);                        System.out.println("after calling notify");                    } catch (InterruptedException e) {                        // TODO Auto-generated catch block                        e.printStackTrace();                    }                }            }        };                pool.submit(threadA);        /*         * jconsole线程         * java.lang.Object@2a14d8c8上的WAITING         * java.lang.Object@2a14d8c8上的BLOCKED, 拥有者: pool-1-thread-2         */        try {            Thread.sleep(30000);        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        pool.submit(threadB);    }}

运行上面的程序，然后打开jconsole查看两个线程的状态变化，可以看出来，blocked状态是线程在被唤醒之后进行锁（除了锁，还有IO资源）的竞争时的状态。

线程池也有对应的状态：RUNNING、SHUTDOWN、STOP、TIDYING、TERMINATED

RUNNING：接收新的任务，并且处理任务队列

SHUTDOWN：不接收新的任务， 但是还在处理任务队列

STOP：不接收新的任务， 不处理任务队列，并且中断正在执行的任务

TIDYING：所有任务终止，workerCount为0，之后会调用terminated()方法

TERMINATED： terminated()方法调用完成

RUNNING -> SHUTDOWN  调用shutdown()方法

(RUNNING or SHUTDOWN) -> STOP 调用shutdownNow()方法

SHUTDOWN -> TIDYING 当线程池和阻塞队列都为空的时候

STOP -> TIDYING 当线程池为空的时候

TIDYING -> TERMINATED terminated()方法调用完成