Java 线程状态

本文按：

一. Java 线程的几种状态及说明

二. 线程状态转换图

三. 示例程序

一. Java线程的状态

Java线程的状态可以在Java.lang.Thread.State中获取到，其中标识的状态有以下六种：

（1）NEW：创建新的线程，还没启动

（2）RUNNABLE：调用start()后正在执行的线程

（3）BLOCKED：阻塞状态，等待锁的释放，
比如线程A进入了一个synchronized方法，线程B也想进入这个方法，但是这个方法的锁已经被线程A获取了，这个时候线程B就处于BLOCKED状态。

（4）WAITING：线程调用了以下方法：
1）Object.wait with no timeout 注意：使用wait()方法时需要先获取锁，否则会报IllegalMonitorLock异常
2）Thread.join with no timeout
3）LockSupport.park
比如线程A调用了Object.wait()方法等待另一个线程B调用Object.notify() or Object.notifyAll()将其唤醒;或者一个线程A调用了Thread.join() 等待另一个线程将其终止。

（5）TIMED_WAITING：线程调用了以下方法：
1) Thread.sleep
2) Object.wait with timeout//等待其他线程调用notify唤醒该线程或者达到超时时间后自动唤醒
3) Thread.join with timeout
4) LockSupport.parkNanos
5) LockSupport.parkUntil

（6）TERMINATED：线程执行完毕

二. 线程状态转换

三.上述线程状态的示例程序

public class ThreadStateSwitch {
    static Object object = new Object();

    @Test
    public void test() {
        //-----------------------------------------------
        //创建线程，状态为 NEW
        Thread thread = new Thread(new NewAndRunnable());
        System.out.println(thread.getState());

        //-----------------------------------------------
        //执行线程，状态为RUNNABLE
        thread.start();
        System.out.println(thread.getState());

        //-----------------------------------------------
        //调用wait() 方法， 状态为WITING
        Thread waitingThread = new Thread(new WaitingState());
        waitingThread.start();
        sleepMainThread(3000);

        //调用notify()方法，唤醒线程
        Thread notifyThread = new Thread(new NotifyThread());
        notifyThread.start();
        System.out.println(waitingThread.getName() + " " + waitingThread.getState());
        sleepMainThread(3000);
        //-----------------------------------------------
        //调用wait() 方法， 状态为TIME_WITING
        Thread timeWaitingThread = new Thread(new TimeWaitingThread());
        timeWaitingThread.start();
        sleepMainThread(6000);

        //-----------------------------
        //调用含有synchronized 的方法， 状态为BLOCKED
        Thread blockThreadA = new Thread(new BlockThreadA());
        Thread blockThreadB = new Thread(new BlockThreadB());
        blockThreadA.start();
        blockThreadB.start();
        System.out.println("blockThreadA " + blockThreadA.getState() + "blockThreadB " + blockThreadB.getState());
        sleepMainThread(3000);
    }


    class NewAndRunnable implements Runnable {
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " NewAndRunnable is running");
        }
    }


    //注意调用wait时需要获取同步锁
    class WaitingState implements Runnable {
        @Override
        public void run() {
            synchronized (object) {
                try {
                    object.wait();
                    for (int i = 0; i < 4; i++) {
                        System.out.println(i + " ");
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


    class NotifyThread implements Runnable {

        @Override
        public void run() {
            synchronized (object) {
                object.notify();
                System.out.println(Thread.currentThread().getName() + " " + Thread.currentThread().getState() + " notify thread");
            }
        }
    }

    class TimeWaitingThread implements Runnable {
        int i = 0;

        @Override
        public void run() {
            synchronized (object) {
                try {
                    object.wait(3000);
                    while (i < 5) {
                        System.out.println(i + "--");
                        i++;
                    }
                    Thread.sleep(1000l);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private void sleepMainThread(int millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    class BlockThreadA implements Runnable {

        @Override
        public void run() {
            block();
        }
    }

    class BlockThreadB implements Runnable {

        @Override
        public void run() {
            block();
        }
    }

    private synchronized void block() {
        int i = 0;
        while (i < 5) {
            System.out.println(i);
            i++;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}