LockSupport

最新推荐文章于 2021-06-18 12:55:59 发布
最新推荐文章于 2021-06-18 12:55:59 发布
阅读量5.5k 收藏 40
点赞数 6
分类专栏： JUC 文章标签： 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42480780/article/details/115904832
版权

LockSupport

LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程。

3种让线程等待和唤醒的方法

  1. 使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程
  2. 使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程
  3. LockSupport类可以阻塞当前线程以及唤醒指定被阻塞的线程

1. 使用Object中的wait()方法让线程等待，使用Object中的notify()方法唤醒线程

// 正常情况下
static Object objectLock = new Object();

    public static void main(String[] args) {
        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();
    }

//输出结果
A	----come in
B	----唤醒动作
A	----被唤醒

//异常情况1：wait()和notify()脱离synchronized单独使用。
static Object objectLock = new Object();

    public static void main(String[] args) {
        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();
    }

//输出结果
java.lang.IllegalMonitorStateException

//异常情况2：先notify(),后wait()，A线程一直处于等待状态。
static Object objectLock = new Object();

    public static void main(String[] args) {
        new Thread(()->{
            //暂停几秒钟，确保B线程先进入。
            try {
                TimeUnit.SECONDS.sleep(3);
            } 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	----唤醒动作
A	----come in

结论：

  1. Object类中的wait、notify、notifyAll用于线程等待和唤醒的方法，都必须在sychronized内部执行（必须用到关键字sychronized），且成对出现使用
  2. 先wait,再notify才可以。

2. 使用JUC包中Condition的await()方法让线程等待，使用signal()方法唤醒线程

//正常情况下
static Object objectLock = new Object();
    static Lock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

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

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

//输出情况
A	----come in
B	----唤醒动作
A	----被唤醒

//异常情况1：注销lock()和unlock()
static Object objectLock = new Object();
    static Lock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

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

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

//输出结果报异常
java.lang.IllegalMonitorStateException

//异常情况2：线程B先进入，即先signal(),后await()
static Object objectLock = new Object();
    static Lock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();

    public static void main(String[] args) {
        new Thread(()->{
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName()+"\t"+"----come in");
                condition.await();
                System.out.println(Thread.currentThread().getName()+"\t"+"----被唤醒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }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	----唤醒动作
A	----come in

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

  1. 线程需要获得并持有锁，必须在锁块（synchronized或lock中）
  2. 必须要先等待后唤醒，线程才能够被唤醒。

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

//不需要在锁块中
    public static void main(String[] args) {
        Thread a = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t" + "----come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t" + "----被唤醒");
        }, "A");
        a.start();
        Thread b = new Thread(() -> {
            LockSupport.unpark(a);
            System.out.println(Thread.currentThread().getName() + "\t" + "----唤醒动作");
        }, "B");
        b.start();
    }

//输出结果
A	----come in
B	----唤醒动作
A	----被唤醒

//先执行unpark(),依然可以被唤醒
public static void main(String[] args) {
        Thread a = new Thread(() -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "\t" + "----come in");
            LockSupport.park();
            System.out.println(Thread.currentThread().getName() + "\t" + "----被唤醒");
        }, "A");
        a.start();
        Thread b = new Thread(() -> {
            LockSupport.unpark(a);
            System.out.println(Thread.currentThread().getName() + "\t" + "----唤醒动作");
        }, "B");
        b.start();
    }

//输出结果
B	----唤醒动作
A	----come in
A	----被唤醒

总结
LockSupport是一个线程阻塞工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，阻塞之后也有对应的唤醒方法。归根揭底，LockSupport调用的是Unsafe中的native代码。

  1. LockSupport类使用了一种名为Permit（许可）的概念来做到阻塞和唤醒线程的功能，每个线程都有一个许可（permit）。
  2. permit只有两个值1和0，默认是0。
  3. 可以把许可看成是一种（0，1）信号量（Semaphore），但与Semaphore不同的是，许可的累加上限是1。
  4. permit默认是0，所以一开始调用park()方法，当前线程就会阻塞，直到别的线程将当前线程的permit设置为1时，park()方法会被唤醒，然后会将permit再次设置为0并返回。

4. 面试题

为什么可以先唤醒线程后阻塞线程
-----因为unpark获取了一个凭证，之后再调用park方法，就可以名正言顺的凭证消费，故不会阻塞。
为什么唤醒两次后阻塞两次，但最终结果还会阻塞线程？
-----因为凭证的数量最多为1，连续调用两次unpark和调用一次unpark效果一样，只会增加一个凭证；而调用两次park却需要消费两个凭证，证不够，不能放行。

一朝红日出
关注
专栏目录
【多线程】LockSupport 使用 原理 源码 分析
九师兄
09-14 445
在介绍java中的Lock时，比如ReentrantLock,ReentReadWriteLocks,已经在介绍线程间等待/通知机制使用的Condition时都会调用LockSupport.park()方法和LockSupport.unpark()方法。而这个在同步组件的实现中被频繁使用的LockSupport到底是何方神圣，现在就来看看。LockSupport位于java.util.concurrent.locks包下，有兴趣的可以直接去看源码，该类的方法并不是很多。
LockSupport详解
热门推荐
Deegue
05-18 1万+
前言 LockSupport是concurrent包中一个工具类，不支持构造，提供了一堆static方法，比如park(),unpark()等。 LockSupport中的主要成员及其加载时的初始化： 不难发现，他们在初始化的时候都是通过Unsafe去获得他们的内存地址，这里也可以理解为C中的指针。 Unsafe Unsafe类可以参考我之前写的文章：深入理解sun.misc.Unsafe原理 ...
【JUC】JDK1.8源码分析之LockSupport（一）
weixin_34402408的博客
04-02 301
一、前言 　　最开始打算分析ReentrantLock，但是分析到最后，发现离不开LockSuport的支持，所以，索性就先开始分析LockSupport，因为它是锁中的基础，是一个提供锁机制的工具类，所以先对其进行分析。 二、LockSupport源码分析 　　2.1 类的属性　 public class LockSupport { // Hotspot impleme...
Java并发编程学习之Unsafe类与LockSupport类源码详析
08-27
《深入解析Java并发编程：Unsafe类与LockSupport类源码剖析》 在Java并发编程领域，Unsafe类和LockSupport类是两个重要的底层工具类，它们提供了低级别的内存操作和线程控制，使得开发者能够实现高效的并发算法和...
详解Java多线程编程中LockSupport类的线程阻塞用法
09-02
在Java多线程编程中，LockSupport类是一个重要的工具，它提供了一种低级别的线程阻塞和唤醒机制。LockSupport并不像synchronized或java.util.concurrent.locks包中的Lock接口那样提供锁的完整功能，但它提供了两个...
Java并发编程 之LockSupport
const_
12-08 266
LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
LockSupport工具
uk8692的专栏
02-28 306
LockSupport定义了一组以park开头的方法用来阻塞当前线程，以及unpark(Thread thread)方法来唤醒一个被阻塞的线程。 方法名称 描述 void park() 阻塞当前线程，如果调用unpark(Thread thread)方法或者当前线程被中断，才能从park()方法返回 void parkNanos(long nanos) 阻塞当前线程，最长不超过...
LockSupport介绍
江黎
12-10 281
可重入锁又名递归锁 是指在同一个线程在外层方法获取锁的时候,再进入该线程的内层方法会自动获取锁(前提:锁对象是同一个对象),不会因为之前已经获取过还没释放而阻塞. Java中的Synchronized和ReentrantLock都是可重入锁,可重入锁的优点是可一定程度避免死锁 LockSupport:用于创建锁和其它同步类的基本线程阻塞原语 简单理解:线程等待唤醒机制(wait/notify)的改良版 LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程.
详解JUC之锁——LockSupport类（04）
腹黑大壁花
05-11 1904
LockSupportLockSupport看名字叫锁支持，这个玩意的功能跟wait和notify很像，它也是可以阻塞一个线程，然后又可以恢复一个线程，不过有个比较大的区别就是，wait让线程阻塞前，必获取到同步锁。而LockSupport这个哥们比较牛逼，随时随地随便阻塞当前线程，你给它一个线程它就敢让那个线程阻塞。它是通过park()方法阻塞当前线程的，park的意思就是停车咯，然后恢复线程就是
JUC锁之LockSupport
liuerchong的博客
06-18 1265
LockSupport是一个线程工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，也可以在任意位置唤醒。 它的内部其实两类主要的方法：park（停车阻塞线程）和unpark（启动唤醒线程）。
LockSupport分析
lwgzj的博客
04-26 427
前几篇分析过wait和notify方法，这两个方法是用来在两个线程之间进行通信的（生产者消费者模型的基本实现）。a.wait()-> b.execute()->b.notify()->a.execute()。我们要知道，在实现两个线程之间能够切换运行时，wait和notify方法其实是运用了一个中间变量，就是Object对象来实现的。今天我们要学习的LockSupport则不是这...
Java线程中断与LockSupport深度解析
"java线程阻塞中断与LockSupport使用介绍" 在Java多线程编程中，线程的阻塞和中断以及同步工具的正确使用至关重要。`Thread.interrupt()` 和 `LockSupport` 是两个关键的概念，它们分别代表了对线程中断机制的不同...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值