Multithreading (2) -- pipeline (4) -- Park and unpark

Basic use

They are LockSupport Methods in class

//  Pause current thread 
LockSupport.park();
//  Resume the running of a thread 
LockSupport.unpark;

Situation 1 ： First park Again unPark：

public static void main(String[] args) throws InterruptedException {
    
    Thread t1 = new Thread(() -> {
    
        try {
    
            log.debug("====start");
            Thread.sleep(1000);
            log.debug("====park");
            //  The thread becomes wait state 
            LockSupport.park();
            log.debug("====resume");
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
    });
    t1.start();

    Thread.sleep(2000);
    log.debug("====unpark");
    LockSupport.unpark(t1);
}

result ：

10:57:28.529 [Thread-0] DEBUG park - ====start
10:57:29.546 [Thread-0] DEBUG park - ====park
10:57:30.529 [main] DEBUG park - ====unpark
10:57:30.530 [Thread-0] DEBUG park - ====resume

Situation two ： First unpark stay park：

modify 2 Time sleep Time for

public static void main(String[] args) throws InterruptedException {
    
    Thread t1 = new Thread(() -> {
    
        try {
    
            log.debug("====start");
            Thread.sleep(2000);
            log.debug("====park");
            LockSupport.park();
            log.debug("====resume");
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
    });
    t1.start();

    Thread.sleep(1000);
    log.debug("====unpark");
    LockSupport.unpark(t1);
}

result ：

11:03:13.374 [Thread-0] DEBUG park - ====start
11:03:14.371 [main] DEBUG park - ====unpark
11:03:15.379 [Thread-0] DEBUG park - ====park
11:03:15.379 [Thread-0] DEBUG park - ====resume

characteristic

And Object Of wait and notify comparison

• wait,notify and notifyall Must cooperate Object Monitor Use it together , and unpark Unwanted
• park and unpark Is to block and wake up threads on a thread by thread basis , and notify Only one waiting thread can be wakened randomly ,notifyAll Is to wake up all waiting threads , Not so precise
• park and unpark You can start with unpark, and wait and notify Not first notify

principle

Each thread has its own Parker object , It's made up of three parts _counter, _cond and _mutex

give an example ：

1. To make an analogy, thread is like a traveler ,Parker Like his backpack , Condition variables, _ cond It's like a tent in a backpack ._counter It's like spare dry food in a backpack （0 To exhaust ,1 For the sake of sufficiency ）
2. call park It depends on whether you need to stop and rest
   1. If the spare dry food runs out , So get into the tent and rest
   2. If there's enough dry food in reserve , Then there is no need to stay , To move forward
3. call unpark, It's like having enough dry food
   1. If the thread is still in the tent , Just wake him up and let him move on
   2. If the thread is still running , So next time he calls park when , Just consume spare dry food , No need to stop and move on
   3. Because the backpack space is limited , Multiple calls unpark Only one spare dry food will be added

Explain the above 1： First call park, Calling unpark

1. call park：

1. Current thread call Unsafe.park() Method
2. Check _counter , This situation is 0, At this time , get _mutex The mutex (mutex Object has a waiting queue _cond)
3. Thread entry _cond Conditional variables block
4. Set up _counter = 0

2. call unpark：

1. call Unsafe.unpark(Thread_0) Method , Set up _counter by 1
2. unpark To blocking queue _cond in , Wake up the _cond In a conditional variable Thread_0
3. Thread_0 Resume operation
4. Set up _counter by 0
   

Explain the above 2： First call unpark, Call again park

1. call Unsafe.unpark(Thread_0) Method , Set up _counter by 1
2. Current thread call Unsafe.park() Method
3. Check _counter , This situation is 1, At this time, the thread does not need to block , Continue operation
4. Set up _counter by 0
   
   If we call continuously 2 Time park, Will cause the thread to block ：

public static void main(String[] args) throws InterruptedException {
    
    Thread t1 = new Thread(() -> {
    
        try {
    
            log.debug("====start");
            Thread.sleep(2000);
            log.debug("====park");
            LockSupport.park();
            LockSupport.park();
            log.debug("====resume");
        } catch (InterruptedException e) {
    
            e.printStackTrace();
        }
    });
    t1.start();

    Thread.sleep(1000);
    log.debug("====unpark");
    LockSupport.unpark(t1);
}

result ：