Java 线程状态，最全输出，详解各个状态关系

import java.util.concurrent.TimeUnit;

/**
 * 线程6个状态，不同条件，打印输出
 */
public class ThreadStateSwitchUnit {
    //线程抢占的对象锁
    public static String obj="我是一个抢手货，锁对象";
    public static synchronized void releaseObjSynLock(){
        //System.out.println("准备释放主线程持有的锁对象");
        synchronized (ThreadStateSwitchUnit.obj){
            ThreadStateSwitchUnit.obj.notifyAll();
        }
        //System.out.println("完成释放主线程的对象锁");
    }
    public static void simulateThreadStateSwitch(){
        long start = System.currentTimeMillis();

        Thread mainThread=new Thread(new MainThread(),"mainThread");
        //创建后，未启动；状态为new
        System.out.println(mainThread.getName()+","+mainThread.getState());
        mainThread.start();
        //启动后，状态进入runnable
        System.out.println(mainThread.getName()+","+mainThread.getState());

        //通过synchronized关键字进入blocked状态,需要辅助线程配合
        Thread subsidiaryThread=new Thread(new SubsidiaryThread(),"subsidiaryThread");
        subsidiaryThread.start();
        //多线程编程，延长主函数生命长度，输出自定义主线程的各个状态
        int i = 9;
        while (i-- > 0) {
            try {
                if(i==2){
                    releaseObjSynLock();
                }
                System.out.println(mainThread.getName()+","+mainThread.getState());
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("pass time = "+(end - start) + " ms");
    }
    public static void main(String[] args) {
        simulateThreadStateSwitch();
    }

}
//辅助线程-配合主线程完成各种状态切换
class SubsidiaryThread implements Runnable{
    @Override
    public void run() {
        synchronized (ThreadStateSwitchUnit.obj){
            //System.out.println(Thread.currentThread().getName()+",我已经拿到obj对象了，主线程你先等着吧");
            try {
                //加大占用对象时间，设置滞留时间段，目的是输出主线程阻塞状态
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
//主线程-主要看它线程状态变化情况
class MainThread implements Runnable{
    @Override
    public void run() {
        //主线程想要获取obj对象，这步让辅助线程先获得对象，这样主线程状态就变成阻塞blocked。
        try {
            //设置滞留时间段，目的是让辅助线程先获得到对象并加锁,并被主线程输出 TIMED_WAITING状态
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (ThreadStateSwitchUnit.obj){
            //System.out.println("拿到对象锁了，立即进入Waiting状态");
            try {
                ThreadStateSwitchUnit.obj.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //System.out.println("重新获得对象锁，继续执行");
            //停滞2秒，输出runnable状态
            long start = System.currentTimeMillis();
            long end = System.currentTimeMillis();
            while(end-start<2000){
                end = System.currentTimeMillis();
            }
        }
        System.out.println(Thread.currentThread().getName()+",终于拿到了Obj对象");
        //到此方法体执行完毕，通过主函数再次打印主线程状态应该为：TERMINATED
    }
}