Java线程状态详解

Java中线程状态

1. NEW： 线程刚创建，还没有调用start()方法；
2. RUNNABLE：线程准备就绪状(即：调用start()方法)或运行中；
3. TIME_WAITING：等待隔一段时间自动唤醒；
4. WAITING： 等待被唤醒；
5. BLOCKED：阻塞，正在等待锁；
6. TERMINATED：线程结束；

线程状态转换图

代码验证状态转换图

NEW、RUNNABLE、TERMINATED状态

public class ThreadStatusTest {
    public static void main(String[] args) throws Exception {
        //  NEW、RUNNABLE、TERMINATED
        Thread t1 = new Thread(() -> {
            System.out.println("2、"+Thread.currentThread().getState()); //线程在执行   输出： RUNNABLE
        });
        System.out.println("1、"+t1.getState()); //此时还没调用start()   输出： NEW
        t1.start(); // 启动t1
        t1.join();  // 等待t1线程执行完毕主线程再继续执行
        System.out.println("3、"+t1.getState()); //此时t1线程一致性完毕  输出： TERMINATED
    }
}

TIMED_WAITING状态

public class ThreadTimedWaitingTest {
    public static void main(String[] args) throws Exception {
        Object o = new Object();

        // TIMED_WAITING
        Thread t2 = new Thread(() -> {
            try {
                // 休眠3s
                TimeUnit.SECONDS.sleep(3);

                synchronized (o) {
                    // 等待3s
                    o.wait(3000);
                }

                Thread thread = new Thread(() -> {
                    try {
                        TimeUnit.SECONDS.sleep(3);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
                thread.start();  // 创建一个线程并
                thread.join(2000);   // thread线程执行完本线程在继续执行

                LockSupport.parkNanos(2000000000);

                LockSupport.parkUntil(System.currentTimeMillis() + 2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        t2.start(); // 启动t2
        TimeUnit.SECONDS.sleep(1); // 休眠1s保证t2线程启动
        System.out.println("4、" + t2.getState());  //输出：4、TIMED_WAITING

        TimeUnit.SECONDS.sleep(3);  // 休眠2s保证t2线程 wait
        System.out.println("5、" + t2.getState());  //输出：5、TIMED_WAITING

        TimeUnit.SECONDS.sleep(3);  // 休眠3s保证 t2在 join(2000)
        System.out.println("6、" + t2.getState()); // 输出： TIMED_WAITING

        TimeUnit.SECONDS.sleep(2); // 休眠2s保证 t2在  LockSupport.parkNanos(2000000000);
        System.out.println("7、" + t2.getState()); // 输出： 7、TIMED_WAITING

        TimeUnit.SECONDS.sleep(1); // 休眠2s保证 t2在 LockSupport.parkUntil(System.currentTimeMillis() + 2000);
        System.out.println("8、" + t2.getState()); // 输出： 8、TIMED_WAITING
    }
}

WAITING状态

public class ThreadWaitingTest {
    public static void main(String[] args) throws Exception {
        Object o = new Object();
        ReentrantLock lock = new ReentrantLock();

        Thread t1 = new Thread(() -> {
            synchronized (o) {
                try {
                    o.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }


            Thread joinThread = new Thread(() -> {
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });

            try {
                joinThread.start();
                joinThread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            LockSupport.park();

            Thread lockThread = new Thread(() -> {
               lock.lock();
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();

                }
            });
            lockThread.start();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            lock.lock();
            lock.unlock();
        });

        t1.start();
        TimeUnit.SECONDS.sleep(1); // 休眠1s，保证t1线程 wait()
        System.out.println("1、" + t1.getState()); // 输出： 1、WAITING
        synchronized (o) {
            o.notify();
        }

        TimeUnit.SECONDS.sleep(1); // 休眠1s， 保证 thread.join();
        System.out.println("2、" + t1.getState()); // 输出： 2、WAITING

        TimeUnit.SECONDS.sleep(2);// 休眠2s，保证 LockSupport.park();
        System.out.println("3、" + t1.getState()); // 输出： 3、WAITING
        LockSupport.unpark(t1);

        TimeUnit.SECONDS.sleep(2); // 休眠2s， 保证lock.lock();
        System.out.println("4、"+t1.getState()); // 输出： 4、WAITING
    }
}

BLOCKED

public class ThreadBlockedTest {

    public static void main(String[] args) throws InterruptedException {
        Object o = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (o){
                try {
                    TimeUnit.SECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (o){

            }
        });
        t1.start();
        TimeUnit.SECONDS.sleep(1); // 休眠1s，保证t1执行
        t2.start();
        TimeUnit.SECONDS.sleep(1);// 休眠1s，保证t2执行
        System.out.println(t2.getState()); // 输出： BLOCKED
    }
}