线程的状态

【工具类】：

public class SleepHelper {
    public static void sleepSeconds(int seconds){
        try{
            TimeUnit.SECONDS.sleep(seconds);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9

【 New_Runnable_Terminated 】：

import Utils.SleepHelper;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class T04_2_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++) {
                        SleepHelper.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());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

【最终输出】：

【 Waiting_TimedWaiting 】：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.LockSupport;

public class T04_2_ThreadState {
    public static void main(String[] args) throws Exception{

        Thread t2 = new Thread(()->{
            try{
                LockSupport.park();
                System.out.println("t2 go on!!!");
                TimeUnit.SECONDS.sleep(5);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        });

        t2.start();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("【1】：" + t2.getState());

        LockSupport.unpark(t2);
        TimeUnit.SECONDS.sleep(1);
        System.out.println("【2】：" + t2.getState());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

【最终输出】：

【Blocked】：

import Utils.SleepHelper;

public class T04_3_ThreadState {
    public static void main(String[] args) throws Exception{
        final Object o = new Object();
        Thread t3 = new Thread(()->{
            //一上来便申请这把锁；
            synchronized (o){
                System.out.println("t3 得到了锁 o");
            }
        });

        new Thread(()->{
            synchronized (o){
                SleepHelper.sleepSeconds(5);
            }
        }).start();

        SleepHelper.sleepSeconds(1);

        t3.start();
        SleepHelper.sleepSeconds(1);
        System.out.println("【一】" + t3.getState());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

【最终结果】：

【Lock 和 synchronized的区别】：

import Utils.SleepHelper;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class T04_4_ThreadState {
    public static void main(String[] args) throws Exception{
        final Lock lock = new ReentrantLock();  // JUC 的锁一般是用 CAS 来实现。会进入一种忙等待（Waiting状态），而非BLOCKED状态。
        Thread t4 = new Thread(()->{
            lock.lock();
            System.out.println( "t4 得到了锁 o " );
            lock.unlock();
        });

        new Thread(()->{
            lock.lock();
            SleepHelper.sleepSeconds(5);
            lock.unlock();
        }).start();

        SleepHelper.sleepSeconds(1);

        t4.start();
        SleepHelper.sleepSeconds(1);
        System.out.println("【一】 "+ t4.getState());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

【输出】：

只有synchronized这样的代码——才会进入BLOCKED状态。因为synchronized是需要经过操作系统的调度的。

【park之后的线程状态】：

import Utils.SleepHelper;
import java.util.concurrent.locks.LockSupport;

public class T04_5_ThreadState_Park后 {
    public static void main(String[] args) throws Exception{
        Thread t5 = new Thread(()->{
            LockSupport.park();
        });

        t5.start();

        SleepHelper.sleepSeconds(1);

        System.out.println("【一】 ： " + t5.getState());
        LockSupport.unpark(t5);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

【输出】：

【图解线程状态】：