ReentrantLock初认知

最新推荐文章于 2024-08-15 14:47:41 发布
最新推荐文章于 2024-08-15 14:47:41 发布
阅读量243 收藏
点赞数
分类专栏： 并发编程 文章标签： java 多线程 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39313241/article/details/114648831
版权

系列文章目录

ReentrantLock初认知
AQS中可重入锁ReentrantLock源码一加锁过程
AQS中可重入锁ReentrantLock源码一释放锁过程
AQS中那些waitStatus(一)
AQS中那些waitStatus(二)

目录

ReentrantLock使用

public class NonFairReentrantLock {

    public static void main(String[] args) {

        final  ReentrantLock lock = new ReentrantLock();

        for (int i = 0; i < 10; i++) {
            new Thread("线程： "+i){
                @Override
                public void run() {
                    lock.lock();  // block until condition holds
                    try {
                        // ... method body
                        System.out.println(Thread.currentThread().getName()+" 开始执行！");
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName()+" 执行结束！");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
                }
            }.start();
        }
        // 主线程阻塞
        LockSupport.park();
    }
}

上面启动了10个线程分别去打印两句话，两句话中间线程会睡眠100ms。通过ReentrantLock的lock和unlock方法来加锁和释放锁。

执行结果:

线程： 0 开始执行！
线程： 0 执行结束！
线程： 1 开始执行！
线程： 1 执行结束！
线程： 2 开始执行！
线程： 2 执行结束！
线程： 3 开始执行！
线程： 3 执行结束！
线程： 4 开始执行！
线程： 4 执行结束！
线程： 5 开始执行！
线程： 5 执行结束！
线程： 6 开始执行！
线程： 6 执行结束！
线程： 7 开始执行！
线程： 7 执行结束！
线程： 8 开始执行！
线程： 8 执行结束！
线程： 9 开始执行！
线程： 9 执行结束！

每个线程都保证了 lock与nulock之间的方法块的互斥性。

推测自己怎么实现（不要较真代码只是屡思路）

ReentrantLock有哪些特性：

  • 共享、独占
  • 可重入性
  • 可中断
  • 公平/非公平

下面我们自己挨个来实现这些特性

共享、独占（互斥性就是同一时刻只有一个线程执行互斥性的代码）

1、直接通过synchronized关键字肯定可以实现，但是我们肯定不是直接用这个。代码就不演示了

2、CAS 加while循环来实现。

public class NonFairReentrantLock {
    // 标记是否被加锁，一定要加volatile，否则线程CAS成功之后其他线程没法感知到
    private volatile  int status;
    // java 写CAS的 标准代码。拷贝就行 --start
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static  long statusOffset;
    static {
        try {
            statusOffset = unsafe.objectFieldOffset(NonFairReentrantLock.class.getDeclaredField("status"));
        } catch (NoSuchFieldException e) {
            
        }
    }
    public boolean CAS(int expect, int update){
        return unsafe.compareAndSwapInt(this, statusOffset,expect,update);
    }
    //java 写CAS的 标准代码。拷贝就行 --end
    private void lock(){
        while (true){
            if(CAS(0,1)){
                return;
            }
        }
    }
    private void unLock(){
      CAS(1,0)
    }
}

// 使用：
NonFairReentrantLock lock = new NonFairReentrantLock()
lock.lock()
  //do something
lock.unlock()
代码逻辑：

  • 多个线程来加锁的时候共同去对status变量赋值从0-1,只要CAS成功就意味着线程拿到了“锁”，就可以执行它的互斥业务代码。

  • 没有拿到锁的线程会一直空循环去在哪里一直尝试CAS。此时逻辑上是没有问题的。

思考：

没有获取到“锁”的线程在哪里死循环，这是致命的。非常的消耗CPU。

解法：
  1. Thread.sleep();
private void lock(){
        while (true){
            if(CAS(0,1)){
                return;
            }else {
              // 没加到锁我们让其睡眠一会？这里我就很纠结了。我到底该睡眠多久。
                Thread.sleep(?????);
            }
        }
    }
  1. Object.wait();
    private void lock() throws InterruptedException {
        while (true){
            if(CAS(0,1)){
                return;
            }else {
                // 是可以等待，但是由谁来唤醒？
                // 的确是可以通过notify(),或者notifyAll()来唤醒，但是这会唤醒该对象关联的所有线程
                // 我们最好只唤醒一个，这样才能避免多个线程再次无效的竞争
                wait();
            }
        }
    }
  1. UNSAFE.park() + UNSAFE.unPark() + 阻塞容器
    private final Deque<Thread> deque = new LinkedList();
    //java 写CAS的 标准代码。拷贝就行 --end
    private void lock() throws InterruptedException {
        while (true){
            if(CAS(0,1)){
                return;
            }else {
                // 阻塞了就放到 阻塞容器里。等别的线程来唤醒
                deque.push(Thread.currentThread());
                // 调用底层的park方法，直接阻塞线程
                UNSAFE.park(false, 0L);// 此处代码只是表示park意思，代码不全
            }
        }
    }
    // 已经获取到锁的线程来释放锁
    private void unLock(){
      	CAS(1,0);
        // unPark()方法可以指定的唤醒一个指定的线程。但是此处有点疑问，这个指定的thread怎么来？
        // 如果在线程被阻塞的时候直接把阻塞的线程引用放到一个容器中。我们从容器中获取一个被阻塞的线程即可。
        Thread thread = deque.pop();
        UNSAFE.unPark(thread);
    }

至此，我觉得解决 独占这个问题思路基本ok了(手动滑稽)。

但是经不起推敲 LinkedList不是可不是线程安全的，如果很多个阻塞线程一起往里面push元素，也会出现线程安全问题。而且线程永远不会被唤醒，等于被遗弃了。那么该线程就会死在那里。但是这个问题我们先遗忘。关注主题思路

可重入性

先解释一下什么是可重入性,对一个锁可以加锁多次，但是必须释放同样的次数。

public class NonFairReentrantLock {
    public static void main(String[] args) {

        final  ReentrantLock lock = new ReentrantLock();

        for (int i = 0; i < 10; i++) {
            new Thread("线程： "+i){
                @Override
                public void run() {
                    lock.lock();  // block until condition holds
                    lock.lock();
                    lock.lock();
                    lock.lock();
                    try {
                        // ... method body
                        System.out.println(Thread.currentThread().getName()+" 开始执行！");
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName()+" 执行结束！");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                        lock.unlock();
                        lock.unlock();
                        lock.unlock();
                    }
                }
            }.start();
        }
        // 主线程阻塞
        LockSupport.park();
    }
}

1、既然支持重入，我们肯定得在lock对象里面记录获取锁的线程，下次该线程再来加锁的时候对比一下。如果还是它自己我们只要将status+1，解锁的时候将status-1就可以了

public class NonFairReentrantLock {
    // 标记是否被加锁
    private volatile int status;
    // java 写CAS的 标准代码。拷贝就行 --start
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static long statusOffset;
    static {
        try {
            statusOffset = unsafe.objectFieldOffset(NonFairReentrantLock.class.getDeclaredField("status"));
        } catch (NoSuchFieldException e) {
        }
    }
    public boolean CAS(int expect, int update) {
        return unsafe.compareAndSwapInt(this, statusOffset, expect, update);
    }
    private final Deque<Thread> deque = new LinkedList();
    private volatile Thread currentThread = null;
    //java 写CAS的 标准代码。拷贝就行 --end
    private void lock() throws InterruptedException {
        while (true) {
            if (CAS(0, 1)) {
                currentThread = Thread.currentThread();
                return;
            } else if (currentThread ==Thread.currentThread()) {
                CAS(status,status+1);
                return;
            } else {
                // 阻塞了就放到 阻塞容器里。等别的线程来唤醒
                deque.push(Thread.currentThread());
                // 调用底层的park方法，直接阻塞线程
                UNSAFE.park(false, 0L);// 此处代码只是表示park意思，代码不全
            }
        }
    }
    // 已经获取到锁的线程来释放锁
    private void unLock() {
        CAS(status,status-1);
        if(status==0){
            // unPark()方法可以指定的唤醒一个指定的线程。但是此处有点疑问，这个指定的thread怎么来？
            // 如果在线程被阻塞的时候直接把阻塞的线程引用放到一个容器中。我们从容器中获取一个被阻塞的线程即可。
            Thread thread = deque.pop();
            UNSAFE.unPark(thread);
        }
    }
}

可中断 ：

线程执行的过程中允许被别的线程中断。最流行的是取消线程上的某些任务.

例如：在应用socket编程的时候，需要创建一个serversocket实例，serversocket类的accept方法就是阻塞方法，即accept会一直等在那里，直到有一个连接请求到达，程序才继续执行。这时候问题就来了，如果没有连接请求，程序会一直阻塞在那里，即不会往下执行，这时候我们就需要中断他。例如可以设置一个等待时间，如果超过此时间，就中断accept方法。

JDK1.5的时候如果想停止一个线程的任务，可以用stop()方法，但是这会直接杀死线程，是非常暴力的。如果这个线程在处理比较重要的逻辑直接杀死线程是非常尴尬的。

微服务的应用优雅下线，肯定不是直接杀死线程，而是传递一个中断信号。让业务自己去处理好中断逻辑。

或者线程在批量提交数据，此时直接杀死线程。肯定会出现数据丢失的问题

公平\非公平

何为公平：谁等的时间长，谁就先被唤醒

何为不公平：唤醒的时候不一定就根据等待时间来决定。可能会被后来的线程提前抢到锁。

七层汉堡王
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
灵活运用ReentrantLock及volatile构造线程安全的CopyOnWriteArrayList
toweryangtao的专栏
06-14 1148
CopyOnWriteArrayList是一个线程安全且在读操作时候无锁的ArrayList,其具体实现如下： 首先在CopyOnWriteArrayList内部定义了一个private类型的数组，并提供getter setter方法，不过需要注意的是该对象数组是被volatile关键字修饰的（关于volatile关键字可以参考我的博客“关于volatile的使用”一文），和ArrayList不
ReentrantLock实现原理详解
08-31
《ReentrantLock实现原理详解》 ReentrantLock作为Java并发编程中的重要工具，相较于内置关键字`synchronized`，它提供了更灵活、更强大的锁控制能力。本文将深入探讨ReentrantLock的实现原理，包括其与`...
并发编程之可重入锁ReentrantLock
勤于笔记，成于点滴。
04-25 878
今天的博文我们讲述了ReentrantLock与Synchronized的区别联系，也解析了ReentrantLock可重入、可中断、超时机制以及conditon变量的源码。通过源码我们可以知道ReentrantLock 是通过AQS保证同步，其他的中断机制、超时机制、以及condition变量也都是基于AQS中的相应底层代码。在实际的开发过程中，我们可以根据自身业务场景选择应用ReentrantLock方法，从而增加系统的健壮性和可维护性。
volatile与ReentrantLock详解
shinerio的博客
04-04 981
volatile与ReentrantLock详解volatile上节我们讲了通过Synchronized可以到方法和代码块进行同步。而用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最新的值。volatile很容易被误用，使用它并不能保证操作的原子性。volatile还会禁止指令排序。我们先进行一个简单的高并发测试 public class Counter { pu
JAVA多线程高并发之ReentrantLock讲解lock/unlock/tryLock方法
饶艳辉
08-10 2836
JAVA中多线程高并发场景下保证线程安全通常都会考虑加锁。但是在特殊场景下我们也可以采用java.util.concurrent包提供的线程安全的对象，避免加锁从而达到高效的目的。 但是，这些线程安全的对象仅仅指的是针对于原子性操作是线程安全的，如果多个方法同时调用无法保证线程安全，只能考虑加锁。这里我们举个列子：假设我们在多线程高并发场景下使用java.util.concurrent.Conc...
JAVA多线程高并发之ReentrantLock讲解lockInterruptibly方法
饶艳辉
08-10 1316
JAVA中多线程高并发场景下保证线程安全通常都会考虑加锁。但是在特殊场景下我们也可以采用java.util.concurrent包提供的线程安全的对象，避免加锁从而达到高效的目的。 但是，这些线程安全的对象仅仅指的是针对于原子性操作是线程安全的，如果多个方法同时调用无法保证线程安全，只能考虑加锁。这里我们举个列子：假设我们在多线程高并发场景下使用java.util.concurrent.Conc...
AQS中可重入锁ReentrantLock源码一加锁过程
weixin_39313241的博客
03-12 491
ReentrantLock类的结构 public class ReentrantLock implements Lock, java.io.Serializable { private static final long serialVersionUID = 7373984872572414699L; /** Synchronizer providing all implementation mechanics */ private final Sync sync; /**
AQS中可重入锁ReentrantLock源码一释放锁过程
weixin_39313241的博客
03-12 326
unlock()方法源码 源码步骤： 调用tryRelease方法进行去操作state变量。每次-1。如果减为0了标识锁被释放 如果锁被释放就去调用unparkSuccessor方法去唤醒下一个未被取消的线程，并且顺带的剔除掉已取消的线程。 同时在整个加锁和释放锁的过程中有很多 waitStatus和线程中断逻辑。下篇详解。 原图地址：https://wangtingblog.oss-cn-beijing.aliyuncs.com/img/解锁.drawio?versionId=CAEQDBiBgMD
JAVA面试总结（初版）
weixin_44995668的博客
04-13 1553
前端 1.HTML 2.方法 2.CSS 3.JS 4.JQuery 4.1.jquery的事件绑定和事件委派的区别是什么 事件绑定：将事件直接与元素进行绑定 事件委派：多用于很多元元素都要绑定事件的情况下，通过子节点绑定的元素传给父节点，来同一管理全部后代子元素，避免了很多重复的事件绑定 4.2、说出10个jquery的选择器 4.3.哪种方式更加高效document.getElementID(‘id’)还是$(‘#ID’) 第一种，因为它直接调用了JavaScript引擎。T…公社7十
AQS中那些waitStatus(一)
weixin_39313241的博客
03-17 7068
waitStatus有哪些 // CANCELLED：由于超时或中断，此节点被取消。节点一旦被取消了就不会再改变状态。特别是，取消节点的线程不会再阻塞。 static final int CANCELLED = 1; // SIGNAL:此节点后面的节点已（或即将）被阻止（通过park），因此当前节点在释放或取消时必须断开后面的节点 // 为了避免竞争，acquire方法时前面的节点必须是SIGNAL状态，然后重试原子acquire，然后在失败时阻塞。 static final int SIGNAL
java ReentrantLock详解
08-26
Java ReentrantLock 详解 Java ReentrantLock 是 Java 1.5 中引入的锁机制，相比于传统的 synchronized 锁，它提供了更加灵活和强大的功能。ReentrantLock 是一种可重入锁，意味着同一个线程可以多次获得锁，而不会...
ReentrantLock.java
02-24
ReentrantLock.java
Java并发之ReentrantLock类源码解析
08-27
Java并发之ReentrantLock类源码解析 ReentrantLock是Java并发包中的一种同步工具，它可以实现可重入锁的功能。ReentrantLock类的源码分析对理解Java并发机制非常重要。本文将对ReentrantLock类的源码进行详细分析，...
使用ReentrantLock和Lambda表达式让同步更
11-22
在高级并发编程中，`ReentrantLock`是一个强大的工具，相较于内置的`synchronized`关键字，它提供了更多的灵活性和控制。本篇文章将深入探讨`ReentrantLock`的使用以及如何结合Lambda表达式来优化同步代码。 `...
帮你深入了解synchronized关键字
weixin_39313241的博客
03-16 164
帮你深入了解synchronized关键字学习这些锁之前先来了解一下MarkWord。什么是重量锁？什么是轻量锁？什么是偏向锁？这几种状态怎么流转？ 学习这些锁之前先来了解一下MarkWord。 由此可见java的设计者们，真的是把mark-word设计到了极限。都是为了省内存啊。 内容都在图里。就不多赘述了。 什么是重量锁？ 这个我觉得人人都应该清楚，其实java以前如果要解决线程安全问题。就...
JAVA进阶补充
最新发布
2301_80150315的博客
08-15 501
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
进程间通信 ---共享内存
BUG制造机的博客
08-14 749
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 509
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
ReentrantLock
08-29
ReentrantLock 是一个可重入的互斥锁，在 Java 中用于实现对共享资源的互斥访问。它比 synchronized 关键字提供了更灵活的锁定操作。ReentrantLock 具有以下特性： 1. 可重入性：同一个线程可以多次获取同一个 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

七层汉堡王

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值