Java高并发学习（六）—— LockSupport

最新推荐文章于 2024-01-13 10:49:54 发布
最新推荐文章于 2024-01-13 10:49:54 发布
阅读量266 收藏 6
点赞数 1
分类专栏： 高并发学习 文章标签： 并发编程 LockSupport
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44855907/article/details/117876079
版权

LockSupport

理论

LockSupport是什么？

LockSupport是Java.util.concurrent.locks包下的一个类。是线程等待唤醒进制的（wait和notify）的改良版。
LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
LockSupport的park() 和unpark(）作用分别是阻塞线程（相当于Object 的wait()）和解除阻塞线程（相当于Object 的notify()）。
在这里插入图片描述

在学习LockSupport之前，我们知道2种让线程等待和唤醒的方法

  1. Object类的wait和notify方法实现线程的等待和唤醒
  2. Condition接口的await()方法和signal()方法实现线程的等待和唤醒。

而通过LockSupport的park() 和unpark(）方法也可以让线程等待和唤醒。

在讲LockSupport之前，有必要知道为什么要引入，也就是LockSupport做到了Object和Condition的没有做到的什么地方？

wait和notify的异常情况

要求：实现线程A等待之后， B线程唤醒A线程继续工作。

package LockSup;

/**
 * @author Johnny Lin
 * @date 2021/6/13 14:25
 *
 * 
 */
public class NotifyWaitDemo {
    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 {
	                System.out.println(Thread.currentThread().getName() + "\t wait……");
	                objectLock.wait();
	                System.out.println(Thread.currentThread().getName()+"\t 被唤醒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

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


    }
}

正常执行结果：
在这里插入图片描述

异常情况1

可是如果将wait和notify所在代码块的synchronized关键字都注释掉，会怎么样呢？

 new Thread(()->{
                System.out.println(Thread.currentThread().getName() + "\t come in");
                try {
	                System.out.println(Thread.currentThread().getName() + "\t wait……");
	                objectLock.wait();
	                System.out.println(Thread.currentThread().getName()+"\t 被唤醒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
        },"A").start();

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

执行结果
在这里插入图片描述

异常情况2

如果是B线程先拿到锁然后执行唤醒，后A再拿到锁进入等待状态会怎么样？

        new Thread(()->{
            //保证B线程先执行拿到锁
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            synchronized (objectLock){
                System.out.println(Thread.currentThread().getName() + "\t come in");
                try {
                    System.out.println(Thread.currentThread().getName() + "\t wait……");
                    objectLock.wait();
                    System.out.println(Thread.currentThread().getName()+"\t 被唤醒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

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

在这里插入图片描述

结论： Obejct类中的wait、notify、notifyAll用于线程等待和唤醒的方法，都必须在synchronized内部执行，且必须要用到关键字synchronized！！

await和signal的异常情况

package LockSup;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Johnny Lin
 * @date 2021/6/13 14:56
 */
public class SignalAwaitDemo {

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

        //让A线程先执行
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(()->{
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t 通知");
            } finally {
                lock.unlock();
            }
        },"B").start();

    }
}

执行结果
在这里插入图片描述

异常情况1

如果把lock()和unlock都注释掉会怎么样？

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

        //让A线程先执行
        try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t 通知");
            } finally {
            }
        },"B").start();

执行结果：

在这里插入图片描述

异常情况2

       new Thread(()->{
            //A线程休眠2秒 保证B线程先执行
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try {
                System.out.println(Thread.currentThread().getName() + "\t wait……");
                try { condition.await(); } catch (InterruptedException e) { e.printStackTrace(); }
                System.out.println(Thread.currentThread().getName()+"\t 被唤醒");
            } finally {
                lock.unlock();
            }
        },"A").start();
        new Thread(()->{
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "\t come in");
            try {
                condition.signal();
                System.out.println(Thread.currentThread().getName() + "\t 通知");
            } finally {
                lock.unlock();
            }
        },"B").start();

在这里插入图片描述

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

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

代码

在 了解了以前Object和Condition的劣处之后自然而然的就引出了LockSupport。

LockSupport类引入一个许可（permit）的概念来做到阻塞和唤醒线程的功能，每个线程都要一个permit。
permit只有两个值1和0，默认是0。permit与semaphore类似，不同的是，permit的累加上限是1 。

官方解释：
。

park()方法

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

LockSupport类

public static void park() { U.park(false, 0L); }

调用Unsafe类的park方法

@HotSpotIntrinsicCandidate
public native void park(boolean isAbsolute, long time);

unpark()方法

调用unpark(thread)方法只有，就会将thread线程的许可permit设置成1，会自动唤醒thread线程，即之前阻塞中的LockSupport.park()方法会立即返回。

注意： 多次调用unpark方法，不会累加。permit值还是1

LockSupport的unpark()方法

public static void unpark(Thread thread) {
if (thread != null)
U.unpark(thread);
}

调用Unsafe类的unpark(Object thread)

@HotSpotIntrinsicCandidate
public native void unpark(Object thread);

package LockSup;

import java.util.concurrent.locks.LockSupport;

/**
 * @author Johnny Lin
 * @date 2021/6/13 15:38
 */
public class LockSupportDemo {
    public static void main(String[] args) {

        Thread A = new Thread(()->{

            System.out.println(Thread.currentThread().getName() + "\t come in");
            System.out.println(Thread.currentThread().getName() + "\t wait……");
            //阻塞
            LockSupport.park();
            System.out.println(Thread.currentThread().getName()+"\t 被唤醒");
        },"A");

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

        A.start();
        B.start();
    }
}

执行结果

在这里插入图片描述

        Thread A = new Thread(()->{
            //A 线程休眠让B线程先执行 发放通行证
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
                System.out.println(Thread.currentThread().getName() + "\t come in");
                System.out.println(Thread.currentThread().getName() + "\t wait……");
                //阻塞
                LockSupport.park();
                System.out.println(Thread.currentThread().getName()+"\t 被唤醒");
        },"A");

        A.start();
        
        Thread B = new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t come in");
            System.out.println(Thread.currentThread().getName() + "\t 通知");
            //通知唤醒A线程
            LockSupport.unpark(A);
            LockSupport.unpark(A);
        }, "B");
        B.start();

执行结果
在这里插入图片描述
可以看到，即使是B先执行unpark()，A线程park()阻塞后也能正常被 唤醒。相当于B线程预先给A发放了通行证。

总结

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

线程阻塞需要消耗凭证permit，这个凭证最多只有1个。当调用park方法时：

  1. 如果有凭证，则会直接消耗这个凭证然后正常退出。
  2. 如果无凭证，则必须阻塞等待凭证可用。

当调用unpark方法时，则会增加一个凭证，但凭证最多只能有1个，累加无效。

JohnnyLin00
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java并发系列：LockSupport
m0_46672151的博客
06-29 296
LockSupport是java.util.concurrent.locks包下的一个类线程等待/通知机制中有三种方法实现： wait()和notify()方法特点：
Java并发编程专题之LockSupport
weixin_42249196的博客
06-13 1228
LockSupport 后续我会发布一系列和并发编程相关的博客，不会太深，也不会太浅，既触碰到源码原理，又不会迷失于细节之中。主要选取的也是面试高频考点，但是我不想只停留在API表面，或者仅仅是收集一些面试题来背，而是会尽力搞清楚他们的原理，让大家能知其然，知其所以然，牢牢记住，构建自己的知识体系。 能力有限，如有错误，希望能批评指正 希望博客能伴我成长，也欢迎小伙伴加我微信：15316162191，大家一起备战秋招 点个关注不迷路~ 概述 LockSupport是一个编程工具类，主要是为了阻塞和唤醒线
Java并发编程 之LockSupport
const_
12-08 238
LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。
Java并发 - LockSupport详解
最新发布
--土拨鼠--
01-13 1382
`LockSupport`是Java中用于实现线程阻塞和唤醒的工具类。它提供了一种基于线程的阻塞原语，能够在不需要持有锁的情况下实现线程的挂起和唤醒操作。
Java并发基础(10)：LockSupport
mingyuli的博客
07-26 536
1、LockSupport简介 LockSupport位于java.util.concurrent.locks包下。LockSupprot是线程的阻塞原语，用来阻塞线程和唤醒线程。每个使用LockSupport的线程都会与一个许可关联，如果该许可可用，并且可在线程中使用，则调用park()将会立即返回，否则可能阻塞。如果许可尚不可用，则可以调用 unpark 使其可用。但是注意许可不可重入，也就是说只能调用一次park()方法，否则会一直阻塞。 LockSupport 类每个使用它的线程...
Java并发编程学习之Unsafe类与LockSupport类源码详析
08-27
《深入解析Java并发编程：Unsafe类与LockSupport类源码剖析》 在Java并发编程领域，Unsafe类和LockSupport类是两个重要的底层工具类，它们提供了低级别的内存操作和线程控制，使得开发者能够实现高效的并发算法和...
java线程阻塞中断与LockSupport使用介绍
09-05
Java线程阻塞中断是Java并发编程中的一个重要概念，它涉及到线程的生命周期管理以及协作。`Thread.interrupt()` 方法是用于向线程发送中断请求，而`LockSupport` 是Java 5引入的一个低级别的线程同步工具，提供了比`...
Java并发编程之LockSupport、Unsafe详解.docx
06-21
在Java并发编程中，LockSupport和Unsafe是两个关键的工具类，它们提供了底层的线程控制功能，使得开发者能够深入地管理和控制线程的行为。LockSupport是Java并发库中的一个核心工具类，它提供了线程的阻塞和唤醒功能...
详解Java多线程编程中LockSupport类的线程阻塞用法
09-02
在Java多线程编程中，LockSupport类是一个重要的工具，它提供了一种低级别的线程阻塞和唤醒机制。LockSupport并不像synchronized或java.util.concurrent.locks包中的Lock接口那样提供锁的完整功能，但它提供了两个...
Java concurrency之LockSupport_动力节点Java学院整理
08-30
Java concurrency之LockSupport是Java并发编程中的一种基础设施，用于创建锁和其他同步类的基本线程阻塞原语。LockSupport提供了一组函数来实现线程之间的同步和通信，使得开发者可以轻松地创建高效、可靠的并发程序...
Java多线程 - LockSupport工具类
你今天真好看呀
03-11 842
文章目录1. LockSupport的常用方法2. LockSupport.park()和Thread.sleep()的区别3. LockSupport.park()与Object.wait()的区别 LockSupport是JUC提供的一个线程阻塞与唤醒的工具类，该工具类可以让线程在任意位置阻塞和唤醒，其所有的方法都是静态方法。 1. LockSupport的常用方法 public class LockSupport { // 无限期阻塞线程 public static void park
Java中关于LockSupport的简单入门记录
weixin_30339969的博客
10-20 93
LockSupport的JDK的文档描述：Basic thread blocking primitives for creating locks and other synchronization classes.（对于创建lock和其他同步类的基础线程原语）。在JUC中有大量使用！ 1 示例: 在主线程中调用LockSupport.park(currentThread);将组线程阻塞，然后通...
LockSupport
weixin_48276298的博客
03-16 181
LockSupport LockSupport简介 LockSupport是用来创建锁和其他同步类的基本线程阻塞原语，官网对于该类的解释如下图所示，LockSupport中的park()和unpark()的作用分别是阻塞线程和解除阻塞线程。 线程等待和唤醒方法 方式一：使用Object中的wait()方法让线程等待， 使用Object中的notify()方法唤醒线程。 代码演示如下： public class LockSupportDemo { static Object objectLock=
java locksupport_Java并发之LockSupport
weixin_29009971的博客
02-16 186
内容导读LockSupport 和 CAS 是Java并发包中很多并发工具控制机制的基础，它们底层其实都是依赖Unsafe实现。LockSupport是用来创建锁和其他同步类的基本 线程阻塞 原语。park()和unpark()不会有 Thread.suspend 和 Thread.resume 所可能引发的死锁问题，由于许可的存在，调用 park 的线程和另一个试图将其 unpark 的线程之间...
Java多线程-LockSupport
weixin_45203607的博客
02-16 660
LockSupport介绍 学过wait/notify 应该都有觉得这个不太好用,因为不能唤醒自己想要的线程,只能随机唤醒一个线程或者全部线程都唤醒,处理不当甚至导致永久的阻塞情况,现在有了LockSupport之后线程的控制就由你自己掌控了,而且和wait/notify不冲突 共同点 LockSupport中的park方法和Object中的wait方法都可以使线程进入WAIT或者TIMED_WAIT状态 LockSupport中的unpark方法和Object中的notify可以使线程脱离WAIT、TIM
【线程、锁】LockSupport示例
m0_45406092的博客
01-30 158
文章目录1. LockSupport的作用2. 演示 1. LockSupport的作用 LockSupport.park() 让当前线程阻塞 LockSupport.unpark(t0) 唤醒to线程，需指定被唤醒的线程 2. 演示 我们创建一个t0线程，该线程内部的run()方法体内实现一个循环打印，但是每次循环时，会调用LockSupport阻塞当前的t0线程，主线程会唤醒一次t0，然后下次循环时会再次陷入循环，这次，就没人再去唤醒t0了，只好永远阻塞下去： package com.test;
自己动手写把”锁”---LockSupport深入浅出
weixin_30485799的博客
01-07 414
本篇是《自己动手写把"锁"》系列技术铺垫的最后一个知识点。本篇主要讲解LockSupport工具类，它用来实现线程的挂起和唤醒。 LockSupport是Java6引入的一个工具类，它简单灵活，应用广泛。 一、简单 俗话说，没有比较就没有伤害。这里咱们还是通过对比来介绍LockSupport的简单。 在没有LockSupport之前，线程的挂起和唤醒咱们都是通过Object的wai...
LockSupport详解
shadow_zed的博客
02-24 1085
LockSupport是一个编程工具类，主要是为了阻塞和唤醒线程用的。使用它我们可以实现很多功能，今天主要就是对这个工具类的讲解，希望对你有帮助： 一、LockSupport简介 1、LockSupport是什么 刚刚开头提到过，LockSupport是一个线程工具类，所有的方法都是静态方法，可以让线程在任意位置阻塞，也可以在任意位置唤醒。 它的内部其实两类主要的方法：park（停车阻塞线程）和unpark（启动唤醒线程）。 注意上面的123方法，都有一个blocker，这个blocke.
浅谈Java并发编程系列（八）—— LockSupport原理剖析
weixin_33948416的博客
02-21 557
LockSupport 用法简介 LockSupport 和 CAS 是Java并发包中很多并发工具控制机制的基础，它们底层其实都是依赖Unsafe实现。 LockSupport是用来创建锁和其他同步类的基本线程阻塞原语。LockSupport 提供park()和unpark()方法实现阻塞线程和解除线程阻塞，LockSupport和每个...
Java并发锁深度解析：从AQS到Condition
"这篇PDF文档主要探讨了Java并发锁的设计与实现，通过对JDK源码的解析，涵盖了AQS（AbstractQueuedSynchronizer）基础同步器、LockSupport工具类、Condition接口、Lock接口、ReadWriteLock接口以及自定义API操作等...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值