JUC-LockSupport（十七）

于 2022-03-14 16:04:31 发布
阅读量164 收藏
点赞数
分类专栏： juc 文章标签： java 开发语言
原文链接：https://blog.csdn.net/oneby1314/article/details/113789332
版权

一、LockSupport 是什么？

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。

LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程，可以将其看作是线程等待唤醒机制(wait/notify)的加强版
在这里插入图片描述

二、传统两种线程等待唤醒的方法

方式1: 使用Object中的wait()方法让线程等待， 使用Object中的notify()方法唤醒线程，与synchronized配合使用。

方式2: 使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程，与Lock 锁配合使用。

方式3: LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

2.1 Object 类

Object类中的wait和notify方法实现线程等待和唤醒

1、正常情况：实现线程的等待和唤醒

static Object objectLock = new Object();

private static void synchronizedWaitNotify() {
    new Thread(() -> {
        synchronized (objectLock) {
            System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
            try {
                objectLock.wait(); // 等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
        }
    }, "A").start();

    new Thread(() -> {
        synchronized (objectLock) {
        	TimeUnit.SECONDS.sleep(3L);
            objectLock.notify(); // 唤醒
            System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
        }
    }, "B").start();
}

程序运行结果：A 线程先执行，执行 objectLock.wait() 后被阻塞，B 线程在 A 线程之后执行 objectLock.notify() 将 A线程唤醒
在这里插入图片描述

2、异常情况一：不在 synchronized 关键字中使用 wait() 和 notify() 方法

static Object objectLock = new Object();

private static void synchronizedWaitNotify() {
    new Thread(() -> {
        //synchronized (objectLock) {
        System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
        try {
            objectLock.wait(); // 等待
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
        //}
    }, "A").start();

    new Thread(() -> {
        //synchronized (objectLock) {
        objectLock.notify(); // 唤醒
        System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
        //}
    }, "B").start();
}

程序运行结果：不在 synchronized 关键字中使用 wait() 和 notify() 方法 ，将抛出 java.lang.IllegalMonitorStateException 异常
在这里插入图片描述

3、异常情况二：先 notify() 后 wait()

static Object objectLock = new Object();

private static void synchronizedWaitNotify() {
    new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(3L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        synchronized (objectLock) {
            System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
            try {
                objectLock.wait(); // 等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
        }
    }, "A").start();

    new Thread(() -> {
        synchronized (objectLock) {
            objectLock.notify(); // 唤醒
            System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
        }
    }, "B").start();
}

程序运行结果：B 线程先执行 objectLock.notify()，A 线程再执行 objectLock.wait()，这样 A 线程无法被唤醒
在这里插入图片描述

2.2 Condition接 口

Condition接口中的await后signal方法实现线程的等待和唤醒

1、正常情况：实现线程的等待和唤醒

static Lock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

private static void lockAwaitSignal() {
    new Thread(() -> {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
        } finally {
            lock.unlock();
        }
    }, "A").start();


    new Thread(() -> {
        lock.lock();
        try {
        	TimeUnit.SECONDS.sleep(3L);
            condition.signal();
            System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
        } finally {
            lock.unlock();
        }
    }, "B").start();
}

程序运行结果：A 线程先执行，执行 condition.await() 后被阻塞，B 线程在 A 线程之后执行 condition.signal() 将 A线程唤醒
在这里插入图片描述

2、异常情况一：不在 lock() 和 unlock() 方法内使用 await() 和 signal() 方法

static Lock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

private static void lockAwaitSignal() {
    new Thread(() -> {
        //lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
        } finally {
            //lock.unlock();
        }
    }, "A").start();


    new Thread(() -> {
        //lock.lock();
        try {
            condition.signal();
            System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
        } finally {
            //lock.unlock();
        }
    }, "B").start();
}

程序运行结果：不在 lock() 和 unlock() 方法内使用 await() 和 signal() 方法，将抛出 java.lang.IllegalMonitorStateException 异常
在这里插入图片描述

3、异常情况二：先 signal() 后 await()

static Lock lock = new ReentrantLock();
static Condition condition = lock.newCondition();

private static void lockAwaitSignal() {
    new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(3L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
            try {
                condition.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
        } finally {
            lock.unlock();
        }
    }, "A").start();


    new Thread(() -> {
        lock.lock();
        try {
            condition.signal();
            System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
        } finally {
            lock.unlock();
        }
    }, "B").start();
}

程序运行结果：B 线程先执行 condition.signal()，A 线程再执行 condition.await()，这样 A 线程无法被唤醒

在这里插入图片描述

2.3 小结

传统的 synchronized 和 Lock 实现等待唤醒通知的约束：

  • 线程先要获得并持有锁，必须在锁块（synchronized或lock）中执行
  • 必须要先等待后唤醒，线程才能够被唤醒

出于这种使用限制，于是有了后来的LockSupport类，其出现就是为了解决这些限制。

三、LockSupport实现线程等待唤醒

3.1 LockSupport 官方介绍

LockSupport 是用来创建锁和其他同步类的基本线程阻塞原语。

LockSupport 类使用了一种名为 permit（许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可（permit），permit 只有两个值 1 和零，默认是零。

可以把许可看成是一种（0, 1）信号量（Semaphore），但与 Semaphore 不同的是，许可的累加上限是 1。
在这里插入图片描述

3.2 LockSupport 的方法

在这里插入图片描述

阻塞方法

park()/park(Object blocker)

作用：阻塞当前线程/阻塞传入的具体线程

permit 默认是 0，所以一开始调用 park() 方法，当前线程就会阻塞，直到别的线程将当前线程的 permit 设置为 1 时，park() 方法会被唤醒，然后会将 permit 再次设置为 0 并返回。

park() 方法通过 Unsafe 类实现:

// Disables the current thread for thread scheduling purposes unless the permit is available.
public static void park() {
    UNSAFE.park(false, 0L);
}

唤醒

unpark(Thread thread)

作用：唤醒处于阻断状态的指定线程

调用 unpark(thread) 方法后，就会将 thread 线程的许可 permit 设置成 1（注意多次调用 unpark()方法，不会累加，permit 值还是 1），继而唤醒目标 thread 线程。

unpark() 方法通过 Unsafe 类实现：

// Makes available the permit for the given thread
public static void unpark(Thread thread) {
    if (thread != null)
        UNSAFE.unpark(thread);
}

3.3 LockSupport 实现等待唤醒

1、正常使用 LockSupport

private static void lockSupportParkUnpark() {
    Thread a = new Thread(() -> {
        System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
        LockSupport.park(); // 线程 A 阻塞
        System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒");
    }, "A");
    a.start();

    new Thread(() -> {
    	TimeUnit.SECONDS.sleep(3L);
        LockSupport.unpark(a); // B 线程唤醒线程 A
        System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
    }, "B").start();
}

程序运行结果：A 线程先执行 LockSupport.park() 方法将通行证（permit）设置为 0，其实这并没有什么用，因为 permit 初始值本来就为 0，然后 B 线程执行 LockSupport.unpark(a) 方法将 permit 设置为 1，此时 A 线程可以通行

在这里插入图片描述

2、先 unpark() 后 park()

private static void lockSupportParkUnpark() {
    Thread a = new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(3L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "\t" + "------come in" + System.currentTimeMillis());
        LockSupport.park();
        System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒" + System.currentTimeMillis());
    }, "A");
    a.start();

    new Thread(() -> {
        LockSupport.unpark(a);
        System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
    }, "B").start();
}

程序运行结果：因为引入了通行证的概念，所以先唤醒（unpark()）其实并不会有什么影响，相当于提前给了许可证，从程序运行结果可以看出，A 线程执行 LockSupport.park() 时并没有被阻塞
在这里插入图片描述

3、验证 permit 上限值为 1

private static void lockSupportParkUnpark() {
    Thread a = new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(3L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "\t" + "------come in" + System.currentTimeMillis());
        LockSupport.park();
        LockSupport.park();
        System.out.println(Thread.currentThread().getName() + "\t" + "------被唤醒" + System.currentTimeMillis());
    }, "A");
    a.start();

    new Thread(() -> {
        LockSupport.unpark(a);
        LockSupport.unpark(a);
        System.out.println(Thread.currentThread().getName() + "\t" + "------通知");
    }, "B").start();
}

程序运行结果：由于 permit 的上限值为 1，所以执行两次 LockSupport.unpark()，但等价于执行了一次，因此将A 线程执行了两次park()阻塞，第二次无法通过。

也许你会短路一下：执行两次park()为啥不等价于执行了一次？你懂的。

在这里插入图片描述

3.4 LockSupport 小总结

以前的等待唤醒通知机制必须synchronized里面执行wait和notify，在lock里面执行await和signal，这上面这两个都必须要持有锁才能干

LockSupport：俗称锁中断，LockSupport 解决了 synchronized 和 lock 的痛点

LockSupport不用持有锁块，不用加锁，程序性能好，无须注意唤醒和阻塞的先后顺序，不容易导致卡死

四、LockSupport 重点说明

  1. LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根结底，LockSupport调用的Unsafe中的native代码。
  2. LockSupport提供park()和unpark()方法实现阻塞线程和解除线程阻塞的过程。
  3. LockSupport和每个使用它的线程都有一个许可(permit)关联。permit相当于1，0的开关，默认是0。调用unpark就变成1，重复调用unpark也不会积累凭证，调用一次park会消费permit，也就是将1变成0。
  4. 当调用park方法时，如果有凭证，则会直接消耗掉这个凭证然后正常通过; 如果无凭证，就必须阻塞等待凭证可用。

为什么可以先唤醒线程后阻塞线程?
因为先调用unpark时，目标线程提前获得了一个凭证，之后再调用park方法，就可以名正言顺的凭证消费，故不会阻塞。

为什么先唤醒两次后再阻塞两次，但最终结果还会阻塞线程?

因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，有且仅有一个凭证；而调用两次park却需要消费两个凭证，第一次park通行了，第二次park无证不能放行。

沉泽·
关注
专栏目录
JUC学习 - LockSupport工具类
TyuIn的博客
11-25 477
一、JUC中的LockSupport工具类 LockSupport位于java.util.concurrent（简称juc）包中，算是juc中一个基础类，juc中很多地方都会使用LockSupport，非常重要！！！ 关于线程等待/唤醒的方法，前面的我们已经讲过2种了： 方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程 方式2：使用juc包中Condition的await()方法让线程等待，使用signal()方法唤醒线程 Object和Condit
JUC 全家桶系列，一键三连就完事了
扛麻袋的少年的博客
12-07 1382
JUC、AQS、CAS、Lock、ReentrantLock、Atomic、Future、Executors、JUC工具类、JUC集合类、Fork-Join框架
JUC锁之LockSupport
liuerchong的博客
06-18 1252
LockSupport是一个线程工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，也可以在任意位置唤醒。 它的内部其实两类主要的方法：park（停车阻塞线程）和unpark（启动唤醒线程）。
java学习系列-高并发13:JUC中的LockSupport工具类，必备技能
星之宇的博客
08-10 244
本文主要内容： 讲解3种让线程等待和唤醒的方法，每种方法配合具体的示例 介绍LockSupport主要用法 对比3种方式，了解他们之间的区别 LockSupport位于**java.util.concurrent（简称juc）**包中，算是juc中一个基础类，juc中很多地方都会使用LockSupport，非常重要，希望大家一定要掌握。 关于线程等待/唤醒的方法，前面的文章中我们已经讲过2种了： 方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程
JUC---LockSupport
蓝天⊙白云的博客
06-07 247
1. LockSupport原理 LockSupport是一个编程工具类，主要是为了阻塞和唤醒线程用的。 LockSiupport的核心方法有两个，park和unpark，park用来阻塞当前调用线程，unpark用来唤醒指定线程。 LockSupport类使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能，可以把许可看成是一种(0,1)信号量（Semaphore），但与 Semaphore 不同的是，许可的累加上限是1。 初始时，permit为0，当调用unpark()方法时，线程的per
juc 之 LockSupport 锁工具
top_explore的博客
06-23 187
public static void main(String[] args) { final Thread thread = new Thread(() -> { System.out.println("阻塞"); LockSupport.park(); System.out.println("已解锁"); }); thread.start(); try { .
Java 多线程与并发(9-26)-JUC锁- LockSupport详解.pdf
最新发布
07-23
LockSupport是Java中用于多线程同步的一个工具类，它提供了一组基础的线程阻塞和解除阻塞的方法。这个类位于java.util.concurrent.locks包下，是实现并发编程中AQS（AbstractQueuedSynchronizer）框架的重要基础之一...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶 Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC...
Java 多线程与并发(7-26)-JUC - 类汇总和学习指南.pdf
07-22
Tools 类则提供了一些有用的工具类，例如 LockSupport 类，用于创建锁和其他同步类的基本线程阻塞原语。 2.Collections： Collections 部分提供了一些并发集合类，例如 CopyOnWriteArrayList、ConcurrentHashMap ...
我学JUC之LockSupport
haoyifen的专栏
03-13 623
java.util.concurrent之LockSupport
JUC 锁之 LockSupport 详解
liuwg1226的专栏
09-09 535
一 概述 今天我们来介绍 Java 并发编程系列之 LockSupport，在介绍 Synchronized 的时候我们有提过，不推荐同学们使用 Object 的 wait、notify、notifyAll 等函数做多线程间的通信协同，使用 LockSupport 会是更好的选择，本篇就来谈谈 LockSupport，也正好为下篇的 AQS（AbstractQueuedSynchronized）打基础。 二 LockSupport 概念 LockSupport 是线程工具类，主要作用是阻塞和唤醒线程，底层
JUC___LockSupport类
define_us的专栏
12-06 160
LockSupport是对Unsafe的一些封装。下面对一些常见方法进行解释。主要提供线程的park和unpark方法。 /** * Disables the current thread for thread scheduling purposes unless the * permit is available. * * <p>If ...
JUC(五)锁机制之LockSupport工具和Condition接口
程序员XW
07-24 338
AQS的内部结构，与其独占式与共享式获取同步状态的实现。但是并没有详细描述线程是如何进行阻塞与唤醒的。我也提到了线程的这些操作都与LockSupport工具类有关。现在我们就一起来探讨一下该类的具体实现。 LockSupport类 了解线程的阻塞和唤醒，我们需要查看LockSupport类。具体代码如下： public class LockSupport { private Loc...
java juc LockSupport详解
qq_37385585的博客
02-02 179
LockSupport是什么 用来创建锁和其他同步类的基本线程阻塞原语 LockSupport就是线程等待唤醒机制 wait/notify 的改良加强版 那么问题来了，为什么要加强等待唤醒机制，原来使用的等待唤醒机制有什么缺点 使用synchornized和Lock的等待唤醒机制 1. 使用Object中的 wait() 方法让线程等待，使用Object中的notify() 方法唤醒线程 问题1.使用wait和notify的时候 必须包裹在synchronized关键字中 使用wait和notify的时候，
通俗易懂的JUC源码剖析-LockSupport
JAVA高级架构
01-30 322
前言LockSupport是rt.jar下的工具类，它的作用是挂起和唤醒线程，它在JUC很多同步组件中都会用到，比如AQS。LockSupport类与每个使用它的线程都会关联一个许可证，...
[JUC] LockSupport浅析
zkp_java的专栏
02-12 367
这里写自定义目录标题wait/notifyLockSupportwait/notify和LockSupport对比LockSupport注意事项参考文献 LockSupport是Java6引入的一个工具类，它简单灵活，应用广泛。在没有LockSupport之前，线程的挂起和唤醒咱们都是通过Object的wait和notify/notifyAll方法实现。 我们以例子来说明两者之间的区别 wait/...
详解JUC之锁——LockSupport类（04）
腹黑大壁花
05-11 1903
LockSupportLockSupport看名字叫锁支持，这个玩意的功能跟wait和notify很像，它也是可以阻塞一个线程，然后又可以恢复一个线程，不过有个比较大的区别就是，wait让线程阻塞前，必获取到同步锁。而LockSupport这个哥们比较牛逼，随时随地随便阻塞当前线程，你给它一个线程它就敢让那个线程阻塞。它是通过park()方法阻塞当前线程的，park的意思就是停车咯，然后恢复线程就是
12-JUC中的LockSupport工具类
永无止境
04-28 214
文章目录关于线程等待/唤醒的方法关于Object类中的用户线程等待和唤醒的方法关于Condition中方法使用总结：Object和Condition的局限性LockSupport类LockSupport中常用的方法总结参考 关于线程等待/唤醒的方法 方式1：使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程 方式2：使用juc包中Condition的...
JUC同步锁: LockSupport 代码Demo
quokka的博客
01-21 167
LockSupport 主要用于对线程执行暂停（park）和唤醒（unpark） import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.LockSupport; public class LockSupportDemo { public static void main(String[] args) { Thread t = new Thread(() -> {
Java并发高级探索： Unsafe与LockSupport详解及JUC框架优化
2. `LockSupport` 类：作为另一个核心工具，`LockSupport` 主要用于线程的阻塞和唤醒，是设计和实现自定义锁的基础。理解其工作原理有助于深入理解JUC中的同步机制。 3. JDK 8 的原子操作：`LongAdder` 是一种特殊...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值