代码模拟线程的6种状态

线程6种状态：

• NEW

Thread state for a thread which has not yet started.

• RUNNABLE

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.

• BLOCKED

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 Object.wait.

• WAITING

Thread state for a waiting thread. A thread is in the waiting state due to calling one of the following methods:

• Object.wait with no timeout
• Thread.join with no timeout
• LockSupport.park

A thread in the waiting state is waiting for another thread to perform a particular action. For example, a thread that has called Object.wait() on an object is waiting for another thread to call Object.notify() or Object.notifyAll() on that object. A thread that has called Thread.join() is waiting for a specified thread to terminate.

• TIME_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:

• Thread.sleep
• Object.wait with timeout
• Thread.join with timeout
• LockSupport.parkNanos
• LockSupport.parkUntil

• TERMINATED

Thread state for a terminated thread. The thread has completed execution.

代码模拟线程的6种状态

public class ThreadState {

    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(() ->{
            System.out.println("2:"+Thread.currentThread().getState());
            for (int i = 0;i < 3;i++){
                SleepHelp1.sleepseconds(1);
                System.out.print(i+" ");
            }
            System.out.println();
        });
        System.out.println("1:"+t1.getState());
        t1.start();
        t1.join();
        System.out.println("3:"+t1.getState());

        //=====================================================================
        Thread t2 = new Thread(()->{
            //阻塞  等着被叫醒  waiting
            LockSupport.park();
            System.out.println("t2 go on");
            SleepHelp1.sleepseconds(5);

        });
        t2.start();
        SleepHelp1.sleepseconds(1);
        System.out.println("4:"+t2.getState());

        //叫醒线程
        LockSupport.unpark(t2);
        SleepHelp1.sleepseconds(1);
        System.out.println("5:"+t2.getState());
        //=====================================================================

        final Object o = new Object();
        Thread t3 = new Thread(()->{
            synchronized (o){
                System.out.println("t3 得到了 锁 o");
            }
        });

        new Thread(()->{
            synchronized (o){
                SleepHelp1.sleepseconds(5);
            }
        }).start();

        SleepHelp1.sleepseconds(1);

        t3.start();

        SleepHelp1.sleepseconds(1);

        System.out.println("6:"+t3.getState());
        //===========================================================
        //juc的锁 盲等待， 不会进入 block 的状态，进入 waiting 状态
        final Lock lock = new ReentrantLock();
        Thread t4 = new Thread(()->{
            lock.lock();//省略掉 try ... finally
            System.out.println("t4 拿到了锁 o");
            lock.unlock();
        });

        new Thread(()->{
            lock.lock();
            SleepHelp1.sleepseconds(5);
            lock.unlock();
        }).start();

        SleepHelp1.sleepseconds(1);

        t4.start();

        SleepHelp1.sleepseconds(1);

        System.out.println("7:"+t4.getState());
        //=======================================================
        Thread t5 = new Thread(()->{
            LockSupport.park();
        });

        t5.start();

        SleepHelp1.sleepseconds(1);

        System.out.println("8:"+t5.getState());

        SleepHelp1.sleepseconds(1);

        LockSupport.unpark(t5);
    }

}

class SleepHelp1 {

    public static void sleepseconds(int seconds){
        try {
            TimeUnit.SECONDS.sleep(seconds);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

}

执行结果：

1:NEW
2:RUNNABLE
0 1 2 
3:TERMINATED
4:WAITING
t2 go on
5:TIMED_WAITING
6:BLOCKED
7:WAITING
t3 得到了 锁 o
8:WAITING
t4 拿到了锁 o