1  概述

        线程在不同的运行时期存在不同的状态，状态信息在存在于State枚举类中，如下图。

        每个状态的解释如下图

 调用于线程有关的方法是造成线程状态改变的主要原因，因果关系如下图

         从上图可知，在调用与线程有关的方法后，线程会进入不同的状态。这些状态之间有些是双向切换，比如WAITING和RUNNING状态之间可以循环地进行切换，而有些是单向切换，比如线程销毁（TERMINATED状态）后，并不能自动进入RUNNING状态。下面将对6中线程状态用代码的方式进行验证。

2 验证NEW RUNNABLE 和 TERMINATED

        了解线程的状态有助于程序员监控线程对象所处的情况，比如哪些线程从未启动，哪些线程正在执行，哪些线程正在组赛等等。

        首先验证的是NEW RUNNABLE 和 TERMINATED 状态。NEW状态是线程实例化后还未执行start()方法，RUNNABLE状态是线程进入运行状态，TERMINATED是线程已被销毁。

public class MyThread extends Thread{
    public MyThread() {
        System.out.println("Thread.currentThread().getState() 构造方法中的状态是：" + Thread.currentThread().getState());
        System.out.println("this.getState 构造方法中的状态是：" + this.getState());
    }

    @Override
    public void run(){
        System.out.println("run方法中的状态是: " + Thread.currentThread().getState());
    }
}

public class Run1 {
    public static void main(String[] args) {
        try {
            MyThread t1 = new MyThread();
            System.out.println("main方法中的状态1? " + t1.getState());
            Thread.sleep(1000);
            t1.start();
            Thread.sleep(1000);
            System.out.println("main方法中的状态? " + t1.getState());
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

3 验证TIMED_WAITING

        TIMED_WAITING 状态代表线程执行了Thread.sleep()方法，呈等待状态，等待时间达到后继续向下运行。

public class MyThread extends Thread{
    @Override
    public void run(){
        try {
            System.out.println("begin sleep");
            Thread.sleep(1000);
            System.out.println("end sleep");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class Run1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.start();
        Thread.sleep(100);
        System.out.println("main方法中的状态:" + t1.getState());
    }
}

4 验证BLOCKED

        BLOCKED状态出现在某一个线程在等待锁的时候。

public class MyService {
    synchronized static public void serviceMethod(){
        try {
            System.out.println(Thread.currentThread().getName() + "进入业务方法");
            Thread.sleep(10000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class MyThread extends Thread{
    @Override
    public void run(){
        MyService.serviceMethod();
    }
}

public class MyThread2 extends Thread{
    @Override
    public void run(){
        MyService.serviceMethod();
    }
}

public class Run1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread t1 = new MyThread();
        t1.setName("t1");
        t1.start();
        Thread.sleep(1000);
        MyThread2 t2 = new MyThread2();
        t2.setName("t2");
        t2.start();
        Thread.sleep(1000);
        System.out.println("main方法中t2状态是：" + t2.getState());
    }
}

        从控制台打印结果看，t2线程一直在等待t1线程释放锁，所以t2当时的状态是BLOCKED。

5 验证WAITING

        WAITING是线程执行了Object.wait()方法后所处的状态。

public class Lock {
    public static final String lock = new String("0");
}

public class MyThread extends Thread{
    @Override
    public void run(){
        try {
            synchronized (Lock.lock){
                Lock.lock.wait();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

public class Run1 {
    public static void main(String[] args) throws InterruptedException {
        MyThread t = new MyThread();
        t.start();
        Thread.sleep(1000);
        System.out.println("main方法中的t状态是:" + t.getState());
    }
}