Java线程的状态

线程一般会有多种状态，Java的状态有：
- NEW
- RUNNABLE
- BLOCKED
- WAITING
- TIMED_WAITING
- TERMINATED

对于各个状态的含义，直接看Thread.java中的源码注释：

public enum State {
        /**
         * Thread state for a thread which has not yet started.
         * 还没有启动的线程状态，比如只定义了一个线程，没有调用strat()方法
         */
        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.
         * 现在在JVM中正在执行，但是需要等待其他资源比如处理器资源，这时候所处的状态
         */
        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()
         * 方法之后重入一个同步块/方法中状态。
         */
        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.
         * 线程等待状态。可能因为调用Object.wait没有超时，Thread.join没有超时，
         * LockSupport.park。
         * 线程等待状态是正在等待另一个线程执行特定操作。
         */
        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>
         * 线程等待特定的时间。调用了sleep，或者带超时的Object.wait，带超时的join，
         * LockSupport的parkNanos或parkUntil等
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         * 结束的线程
         */
        TERMINATED;
    }

这几种状态，可以写程序测试一下：

    Thread thread1 = new Thread(new Runnable() {

        @Override
        public void run() {
        System.out.println("thread 1");
        }
    });

    System.out.println("state: "+thread1.getState());

输出：

state: NEW

    Thread thread1 = new Thread(new Runnable() {

        @Override
        public void run() {
        System.out.println("thread 1");
        }
    });

    System.out.println("state: "+thread1.getState());
    thread1.start();
    System.out.println("state: "+thread1.getState());

输出：

state: NEW
state: RUNNABLE
thread 1

生产者-消费者模型中，生产者速度没有消费者快导致没有足够可消费物品时，消费者就会等待：

    final Object lock = new Object();
    Thread t1 = new Thread() {
        @Override
        public void run() {

        int i = 0;

        while (true) {
            synchronized (lock) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                }
                    System.out.println(i++);
                }
            }
        }
    };

    t1.start();
    System.out.println("state: " + t1.getState());

输出：

state: WAITING

    final Object lock = new Object();
    Thread t1 = new Thread() {
        @Override
        public void run() {

        int i = 0;

        while (true) {
            synchronized (lock) {
            try {
                lock.wait(20 * 1000L);
            } catch (InterruptedException e) {
            }
            System.out.println(i++);
            }
        }
        }
    };

    t1.start();
    Thread.sleep(1000);
    System.out.println("state: " + t1.getState());

输出：

state: TIMED_WAITING

public class BlockTest {

    final Object lock = new Object();

    public BlockTest() {

    }

    public void test(){
    synchronized(lock){
        while(true){

        }
    }
    }

    public void run() throws InterruptedException{
    Runnable r = new Runnable() {

        @Override
        public void run() {
        test();
        }
    };
    Thread t1 = new Thread(r);
    Thread t2 = new Thread(r);
    t1.start();
    Thread.sleep(1000);
    t2.start();
    System.out.println("thread1: "+t1.getState());
    System.out.println("thread2: "+t2.getState());
    }
}

输出：

thread1: RUNNABLE
thread2: BLOCKED

    Thread t1 = new Thread(new Runnable() {

        @Override
        public void run() {
        System.out.println("thread 1 running");
        }
    });
    t1.start();
    Thread.sleep(1000);
    System.out.println("thread1 :"+t1.getState());

输出：

thread 1 running
thread1 :TERMINATED