LockSupport的使用（细节拉满）

ps酷教程

已于 2023-09-23 21:53:11 修改

阅读量1k

点赞数

分类专栏： # 并发文章标签： java

于 2022-11-28 22:27:42 首次发布

本文链接：https://blog.csdn.net/qq_16992475/article/details/128088521

版权

并发专栏收录该内容

14 篇文章 1 订阅

订阅专栏

文章目录

参考链接：

LockSupport使用场景及原理详解
 AQS的引入

LockSupport的使用

LockSupport是一个工具类，提供了基本的线程阻塞和唤醒功能，它是创建锁和其他同步组件的基础工具，内部是使用sun.misc.Unsafe类实现的。LockSupport和使用它的线程都会关联一个许可，park方法表示消耗一个许可，调用park方法时，如果许可可用则park方法返回，如果没有许可则一直阻塞直到许可可用。unpark方法表示增加一个许可，多次调用并不会积累许可，因为许可数最大值为1。

其次，注意：某个线程可以先被unpark（这时，该线程就获得了一个许可），然后这个线程调用LockSupport.park()时，此时，发现有许可可用，则使用此许可而不会阻塞。

关于LockSupport的补充

LockSupport会为每个线程设置一个permit值，也就是许可。1代表许可可用，0代表许可不可用。permit的最大值是1，最小值是0，当调用park()方法时，如果permit为1，则减为0，继续执行。如果permit已经为0，则阻塞。同理，unpark()方法会消耗一个许可，如果permit的值为0，则增加为1，代表发放许可，如果permit的值已经为1，则不在增加，也就是多次方法许可，并不会累加。当然这里所讲的permit在LockSupport的代码当中没有体现，需要到HotSpot的源码当中查看，以下为截图供查看：

1、/share/vm/runtime/park.hpp中许可的定义字段_counter
在这里插入图片描述

2、park()的实现(部分截图)
在这里插入图片描述

3、unpark()实现
在这里插入图片描述

示例：让3个线程按顺序打印ABC

package com.zzhua;

import java.util.concurrent.locks.LockSupport;

public class TestABC {

    private void printA(Thread thread) {
        System.out.println("A");
        LockSupport.unpark(thread);
    }

    private void printB(Thread thread) {
        LockSupport.park();
        System.out.println("B");
        LockSupport.unpark(thread);
    }

    private void printC() {
        LockSupport.park();
        System.out.println("C");
    }

    public static void main(String[] args) {

		/* 无论下面哪个线程先被执行，当B和C未获得它们的许可时，都会被阻塞掉，一直到获得许可。
		   或者，它们在它们执行顺先前面的线程执行完后，先给了它们许可后，它们再在park时，再消费此许可
		   这样就可以保证它们的打印顺序
		   LockSupport的存在目的就是为了替换掉jdk自带的wait-notify等待唤醒机制(它只能结合synchronized使用，并且只能唤醒一个或全部唤醒，不够灵活) */
		
        TestABC testABC = new TestABC();

        Thread tC = new Thread(() -> {
            testABC.printC();
        });

        Thread tB = new Thread(() -> {
            testABC.printB(tC);
        });

        Thread tA = new Thread(() -> {
            testABC.printA(tB);
        });

        tC.start();
        tB.start();
        tA.start();

    }

}

可正常响应中断

LockSupport.park()方法可以阻塞当前线程，阻塞的过程中，是可以正常响应中断的（如下面例子）。而jdk自带的synchornized当处于阻塞时，是不会响应中断的。

package com.zzhua;

import java.util.concurrent.locks.LockSupport;

public class TestPark {

    public static void main(String[] args) {

        Thread mainThread = Thread.currentThread();

        new Thread(() -> {
            try {
                Thread.sleep(3000L);
                mainThread.interrupt();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        
        LockSupport.park();
        
        System.out.println("main....");

		// 3s后，正常输出main....
		// 说明park()方法可正常响应中断

    }

}

jdk自带的synchronized在阻塞期间是不会响应中断的，以下示例，在10s后，正常输出main…


package com.zzhua;


public class TestPark {

    public static void main(String[] args) throws InterruptedException {

        Thread mainThread = Thread.currentThread();

        new Thread(() -> {
            try {
                Thread.sleep(3000L);
                mainThread.interrupt();
                System.out.println("尝试中断main线程...(但是main线程没反应)");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                synchronized (TestPark.class) {
                    Thread.sleep(10000L);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        Thread.sleep(50L);

        System.out.println("要进入synchronized了");
        synchronized (TestPark.class) {
            System.out.println("main....");
        }

    }

}

打断标记与park（细节拉满）

调用park之前，线程的打断标记状态都是false，但是有的能park住，有的调用park没有作用

（解释一：调用interrupt()时，其实也隐藏会调用unpark()，就相当于给这个打断的线程颁发了一次许可）。

（解释二：当isInterrupted中断标记为true的时候，后面的park都不会成功）

package com.zzhua.test32;

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

public class Test32 {
    public static void main(String[] args) {
        /*
		// 线程被打断（就会颁发了一次许可），第一次park，将会park不住
        System.out.println(Thread.currentThread().isInterrupted()); // false
        Thread.currentThread().interrupt();                         // 打断当前主线程
        System.out.println(Thread.currentThread().isInterrupted()); // true
        System.out.println(Thread.interrupted());                   // 返回打断标记状态，并且清除打断标记
        System.out.println(Thread.currentThread().isInterrupted()); // false
        LockSupport.park();                                         // 在清除打断标记的情况下，去park
        System.out.println(123);                                    // 前面没有park住,这里输出123

        */

        /*
        // 线程被打断（就会颁发了一次许可），第一次park，将会park不住
        System.out.println(Thread.currentThread().isInterrupted()); // false
        Thread.currentThread().interrupt();                         // 打断当前主线程
        System.out.println(Thread.currentThread().isInterrupted()); // true
        LockSupport.park();                                         // 在打断的情况下，去park
        System.out.println(123);                                    // 前面没有park住,这里输出123
        System.out.println(Thread.currentThread().isInterrupted()); // true
        */

        /* 因为清除了打断标记，主线程才得以成功park住
        Thread mainThread = Thread.currentThread();
        new Thread(()->{
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            mainThread.interrupt();                      // 3s之后，打断主线程
            System.out.println("打断main线程");
        }).start();
        System.out.println("main即将进入park"); 
        LockSupport.park();                              // 主线程park
        System.out.println(mainThread.isInterrupted());  // true
        System.out.println("main恢复运行");
        Thread.interrupted();                            // 返回打断标记状态，并且清除打断标记
        System.out.println(mainThread.isInterrupted());  // false
        LockSupport.park();                              // 主线程成功park
        */
        
        /* 当isInterrupted中断标记为true的时候，park不会成功
        Thread test = new Thread(() -> {
            Thread.currentThread().interrupt();
            LockSupport.park();
            System.out.println("第1次park");//park不住，还会执行
            Thread.interrupted();//为什么aqs要用interrupted()：设置isInterrupted为false，aqs用unpark唤醒，后续才能park住，
            LockSupport.park();
            System.out.println("第2次park");
            if (Thread.currentThread().isInterrupted()) {
                System.out.println("通过interrupt唤醒");
            } else {
                System.out.println("通过unpark唤醒");
            }
            LockSupport.park();//打断标记为true，无法park;false，可以Park
            System.out.println("第3次park");
            LockSupport.park();
            System.out.println("再来一次park试试，park不住呀" + Thread.currentThread().isInterrupted());
        });


        test.start();
        Thread.sleep(1000);
        // LockSupport.unpark(test);//对应false，可以park的情况，aqs用unpark唤醒后
        test.interrupt();//对应true，无法park的情况，aqs selfInterrupt后，无法再次park住
        
        */

    }
}