JUC并发编程(7.Java线程）

不念不忘少年蓝@ 2024-03-27 13:34 26阅读 0赞

## 1.Park & Unpark ##

### 1.1 基本使用 ###

它们是 LockSupport 类中的方法

> // 暂停当前线程  
> LockSupport.park();  
> // 恢复某个线程的运行  
> LockSupport.unpark(暂停线程对象)

> **先 park 再 unpark**

public class TestParkUnpark {
        
        public static void main(String[] args) {
        
            Thread t1 = new Thread(() -> {
        
                log.debug("start...");
                sleep(1);
                log.debug("park...");
                LockSupport.park();
                log.debug("resume...");
            }, "t1");
            t1.start();
    
            sleep(2);
            log.debug("unpark...");
            LockSupport.unpark(t1);
        }
    }

11:35:21.942 c.TestParkUnpark [t1] - start...
    11:35:22.953 c.TestParkUnpark [t1] - park...
    11:35:23.956 c.TestParkUnpark [main] - unpark...
    11:35:23.956 c.TestParkUnpark [t1] - resume...

> **先 unpark 再 park**

public class TestParkUnpark {
        
        public static void main(String[] args) {
        
            Thread t1 = new Thread(() -> {
        
                log.debug("start...");
                sleep(2);
                log.debug("park...");
                LockSupport.park();
                log.debug("resume...");
            }, "t1");
            t1.start();
    
            sleep(1);
            log.debug("unpark...");
            LockSupport.unpark(t1);
        }
    }

11:34:19.051 c.TestParkUnpark [t1] - start...
    11:34:20.055 c.TestParkUnpark [main] - unpark...
    11:34:21.060 c.TestParkUnpark [t1] - park...
    11:34:21.060 c.TestParkUnpark [t1] - resume...

### 1.2**Park & Unpark与 Object 的 wait & notify 相比** ###

*  wait，notify 和 notifyAll 必须配合`Object Monitor` 一起使用，而 `park`，`unpark` 不必
 *  `park & unpark`是以`线程为单位`来`【阻塞】和【唤醒】线程`，而 n**otify 只能随机唤醒一个等待线程，notifyAll是唤醒所有等待线程**，就不那么【精确】
 *  **park & unpark 可以先 unpark**，而 **wait & notify 不能先 notify**

### 1.3 Park & Unpark的底层实现原理 ###

![在这里插入图片描述][7e006c70a8614e7890b89fe860f8ae5f.png]

#### 1）Unsafe.Park()方法,\_counter 为0 ####

![e8cba064befa4e12ae57263e2e1b003f.png][]  
![在这里插入图片描述][ae636a5bba454164b118eda25485189b.png]

#### 2）Unsafe.Park()方法，,\_counter 为1 ####

![在这里插入图片描述][48636b625b674e8da5518742bd52b101.png]  
![在这里插入图片描述][360c2489446b4463b6e09b18299aac50.png]

#### 3）Unsafe.unpark()方法 ####

![在这里插入图片描述][4c4031867a904909b32c076a4fd0772d.png]

![在这里插入图片描述][f5cccb5280264378abe9dd16f9e7c7e8.png]

## 2.重新理解线程状态转换 ##

![在这里插入图片描述][6bb932baaf5c40e982c2d3755847708b.png]

假设有线程 Thread t

### 1）情况 1 NEW --> RUNNABLE ###

当调用 t.start() 方法时，由 `NEW` \--> `RUNNABLE`

### 2）情况 2 RUNNABLE <–> WAITING ###

t 线程用`synchronized(obj)`获取了对象锁后

*  调用`obj.wait()`方法时，t 线程从 RUNNABLE --> WAITING
 *  调用`obj.notify()` ， `obj.notifyAll()`，`t.interrupt()`时
    
     *  竞争锁成功，t 线程从 `WAITING` \--> `RUNNABLE`
     *  竞争锁失败，t 线程从 `WAITING` \--> `BLOCKED`

public class TestWaitNotify {
        
        final static Object obj = new Object();
    
        public static void main(String[] args) {
        
    
            new Thread(() -> {
        
                synchronized (obj) {
        
                    log.debug("执行....");
                    try {
        
                        obj.wait(); // 让线程在obj上一直等待下去
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    log.debug("其它代码....");// 断点
                }
            },"t1").start();
    
            new Thread(() -> {
        
                synchronized (obj) {
        
                    log.debug("执行....");
                    try {
        
                        obj.wait(); // 让线程在obj上一直等待下去
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                    log.debug("其它代码....");// 断点
                }
            },"t2").start();
    
            // 主线程两秒后执行
            sleep(0.5);
            log.debug("唤醒 obj 上其它线程");
            synchronized (obj) {
        
    //            obj.notify(); // 唤醒obj上一个线程
                obj.notifyAll(); // 唤醒obj上所有等待线程// 断点
            }
        }
    }

12:00:13.120 c.TestWaitNotify [t1] - 执行....
    12:00:13.121 c.TestWaitNotify [t2] - 执行....
    12:00:13.623 c.TestWaitNotify [main] - 唤醒 obj 上其它线程
    12:00:24.431 c.TestWaitNotify [t2] - 其它代码....
    12:00:33.418 c.TestWaitNotify [t1] - 其它代码....

### 3）情况 3 RUNNABLE <–> WAITING ###

*  当前线程调用`t.join()`方法时，当前线程从 `RUNNABLE`–> `WAITING`
    
     *  注意是当前线程在t 线程对象的监视器上等待
 *  t 线程运行结束，或调用了当前线程的 `interrupt()`时，当前线程从 `WAITING` \--> `RUNNABLE`

### 4）情况 4 RUNNABLE <–> WAITING ###

*  当前线程调用 `LockSupport.park()`方法会让当前线程从 `RUNNABLE` \--> `WAITING`
 *  调用 `LockSupport.unpark`(目标线程) 或调用了线程 的 interrupt() ，会让目标线程从 `WAITING`–>`RUNNABLE`

### 5）情况 5 RUNNABLE <–> TIMED\_WAITING ###

t 线程用 `synchronized(obj)` 获取了对象锁后

*  调用 `obj.wait(long n)`方法时，t 线程从 `RUNNABLE` \--> `TIMED_WAITING`
 *  t 线程等待时间超过了 n 毫秒，或调用 `obj.notify()`， `obj.notifyAll()` ， `t.interrupt()`时
    
     *  竞争锁成功，t 线程从`TIMED_WAITING` \--> `RUNNABLE`
     *  竞争锁失败，t 线程从 `TIMED_WAITING` \-->`BLOCKED`

### 6）情况 6 RUNNABLE <–> TIMED\_WAITING ###

*  当前线程调用`t.join(long n)`方法时，当前线程从 `RUNNABLE` \--> `TIMED_WAITING`
    
     *  注意是当前线程在t 线程对象的监视器上等待
 *  当前线程等待时间超过了 n 毫秒，或t 线程运行结束，或调用了当前线程的 interrupt() 时，当前线程从`TIMED_WAITING`–> `RUNNABLE`

### 7）情况 7 RUNNABLE <–> TIMED\_WAITING ###

*  当前线程调用`Thread.sleep(long n)`，当前线程从 `RUNNABLE` \--> `TIMED_WAITING`
 *  当前线程等待时间超过了 n 毫秒，当前线程从 `TIMED_WAITING`–> `RUNNABLE`

### 8）情况 8 RUNNABLE <–> TIMED\_WAITING ###

*  当前线程调用 `LockSupport.parkNanos(long nanos)`或 Lock`Support.parkUntil(long millis)`时，当前线程从`RUNNABLE` \--> `TIMED_WAITING`
 *  调用 `LockSupport.unpark(`目标线程) 或调用了线程 的 `interrupt()`，或是等待超时，会让目标线程从`TIMED_WAITING`–> `RUNNABLE`

### 9）情况 9 RUNNABLE <–> BLOCKED ###

*  t 线程用 `synchronized(obj)`获取了对象锁时如果竞争失败，从 `RUNNABLE` \--> `BLOCKED`
 *  持 obj 锁线程的同步代码块执行完毕，会唤醒该对象上所有 BLOCKED 的线程重新竞争，如果其中 t 线程竞争成功，从 `BLOCKED` \--> `RUNNABLE` ，其它失败的线程仍然 `BLOCKED`

### 10）情况 10 RUNNABLE <–> TERMINATED ###

当前线程所有代码运行完毕，进入`TERMINATED`

[7e006c70a8614e7890b89fe860f8ae5f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/fe3bbc62376e4455a3aef5cae5fa3860.png
[e8cba064befa4e12ae57263e2e1b003f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/061b06b94fe848d2b1b42a9732314170.png
[ae636a5bba454164b118eda25485189b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/c572765c4f3349af8d6f99817c1041fe.png
[48636b625b674e8da5518742bd52b101.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5e4c9971766741c2a4a8d731c0b1c4b9.png
[360c2489446b4463b6e09b18299aac50.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/283f2b8e2cf5457992e499e1ea495e53.png
[4c4031867a904909b32c076a4fd0772d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ce58c718bb7e4d378488bc6bf9b79ed8.png
[f5cccb5280264378abe9dd16f9e7c7e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/a66d79ed13624f0487bc10cc31d21b69.png
[6bb932baaf5c40e982c2d3755847708b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/be531d0d4a85403b84debd87a42853ce.png