我的编程空间,编程开发者的网络收藏夹
学习永远不晚

Java 多线程并发ReentrantLock

短信预约 -IT技能 免费直播动态提醒
省份

北京

  • 北京
  • 上海
  • 天津
  • 重庆
  • 河北
  • 山东
  • 辽宁
  • 黑龙江
  • 吉林
  • 甘肃
  • 青海
  • 河南
  • 江苏
  • 湖北
  • 湖南
  • 江西
  • 浙江
  • 广东
  • 云南
  • 福建
  • 海南
  • 山西
  • 四川
  • 陕西
  • 贵州
  • 安徽
  • 广西
  • 内蒙
  • 西藏
  • 新疆
  • 宁夏
  • 兵团
手机号立即预约

请填写图片验证码后获取短信验证码

看不清楚,换张图片

免费获取短信验证码

Java 多线程并发ReentrantLock

背景

在 Java 中实现线程安全的传统方式是 synchronized 关键字,虽然它提供了一定的同步能力,但它在使用上是严格的互斥同步实现:一个线程只能获取一次锁,没有给其他线程提供等待队列等机制,以至于当一个锁被释放后,任意线程都有可能获取到锁,没有线程等待的优先级顺序,会导致重要的线程在没有争用到锁的情况下,长时间阻塞。为了解决 synchronized 的痛点,Java 提供了 ReentrantLock 可重入锁来提供更丰富的能力和灵活性。

ReentrantLock

ReentrantLock 是一种可重入互斥锁,其基本能力与使用 synchronized 关键字相同,但拓展了一些功能。它实现了 Lock 接口,在访问共享资源时提供了同步的方法。操作共享资源的代码被加锁和解锁方法的调用之间,从而确保当前线程在调用加锁方法后,阻止其他线程试图访问共享资源。

可重入特性

ReentrantLock 由上次成功锁定的但尚未解锁的线程持有;当锁不被任何线程拥有时,调用 lock 方法的线程将获取到这个 ReentrantLock,如果当前线程已经拥有 ReentrantLock ,lock 方法会立即返回。

ReentrantLock 允许线程多次进入资源锁。当线程第一次进入锁时,保持计数设置为 1。在解锁之前,线程可以再次重新进入锁定状态,并且每次保持计数加一。对于每个解锁请求,保持计数减一,当保持计数为 0 时,资源被解锁。

公平锁设置参数

ReentrantLock 的构造器接收一个可选的 fairness 参数(Boolean 类型)。当设置为 true 时,在线程争用时,锁优先授予等待时间最长的线程访问。否则,此锁不保证任何特定的顺序。但是请注意,锁的公平性不能保证线程调度的公平性。

可重入锁还提供了一个公平参数,通过该参数,锁将遵循锁请求的顺序,即在线程解锁资源后,锁将转到等待时间最长的线程。这种公平模式是通过将 true 传递给锁的构造函数来设置的。

源码分析

Lock 接口

ReentrantLock 实现了 Lock 接口,所以分析源码先从 Lock 接口开始:

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();​
    Condition newCondition();
}

Lock 接口定义了更灵活和更广泛的锁定操作。synchronized 关键字是 JVM 底层提供了 monitor 指令的形式加锁,这导致了获取多个锁时,需要按获取顺序的倒序解锁。Lock 就是为了解决这种不够灵活的问题而出现的。Lock 接口的实现通过允许在不同范围内获取和释放锁以及允许多个锁按任意顺序的获取和释放。随着这种灵活性的增加,额外的职责也就随之而来,synchronized 关键字以代码块的结构加锁,执行完成锁会自动释放,而 Lock 的实现则需要手动释放锁,大多数情况下,

应该使用下面的语句实现:

 Lock l = ...;
 l.lock();
 try {
   // access the resource protected by this lock
 } finally {
   l.unlock();
 }

当锁定和解锁发生在不同的作用域时,必须注意确保所有在持有锁时执行的代码都受到 try-finally 或 try-catch 的保护,以确保在必要时释放锁。

Lock 接口中定义的方法可以划分为三部分:

  • 加锁操作
  • 解锁操作
  • newCondition

加锁操作

加锁操作提供了四个方法:

    // 获取锁,如果锁不可用,则当前线程将被禁用以用于线程调度目的并处于休眠状态,直到获取到锁为止。
    void lock();​
    void lockInterruptibly() throws InterruptedException;
   boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

lock():获取锁,如果无法获取到,则当前线程进入阻塞状态,直到获取到锁为止。

lockInterruptibly():除非当前线程被中断,否则去获取锁。如果获取到了锁,则立即返回。如果没有争用到锁,则当前线程阻塞,直到发生下面两种情况之一:

如果当前线程:

以上两种情况都会抛出 InterruptedException ,并清除当前线程的中断状态。

  • 当前线程获取到了锁
  • 其他线程中断了当前线程
  • 在进入此方法时,设置了中断状态
  • 在获取锁的过程中被中断

tryLock()

仅当锁处于空闲状态时,才获取锁。获取到锁立即返回 true,如果锁被其他线程持有,则此方法立即返回 false 。

此方法的典型用法是:

 Lock lock = ...;
 if (lock.tryLock()) {
   try {
     // manipulate protected state
   } finally {
     lock.unlock();
   }
 } else {
   // perform alternative actions
 }

这种用法确保锁在获得时解锁,并且在未获得锁时不尝试解锁。

tryLock(long time, TimeUnit unit)

  • 如果在给定时间内锁处于空闲状态,且当前线程没有被中断,则获取锁。
  • 如果当前线程成功获取到了锁,则此方法立即返回 true ;如果当前线程无法获取到锁,则当前线程会进入阻塞状态直到发生下面三种情况之一:
  • 如果进入此方法时当前线程处于中断状态或获取锁的过程中已进入中断状态,以上两种情况都会抛出 InterruptedException ,并清除当前线程的中断状态。
  • 此外,如果 time 参数小于等于 0 ,该方法不会等待。
    • 锁被当前线程成功获取
    • 指定时间超时
    • 其他线程中断了当前线程

解锁操作:

解锁操作只提供了 unlock() 方法。

newCondition:

返回绑定到此 Lock 的 Condition 实例。

内部类

ReentrantLock 有三个内部类,分别是 Sync、NonfairSync、FairSync 。

它们的继承关系是:

Sync

这个类是 AQS 的直接实现,它为公平锁实现 FairSync 和非公平锁实现 NonfairSync 提供了共同的基础能力。

abstract static class Sync extends AbstractQueuedSynchronizer {
    @ReservedStackAccess
    final boolean tryLock()
    abstract boolean initialTryLock();
    @ReservedStackAccess
    final void lock()
    @ReservedStackAccess
    final void lockInterruptibly()
    @ReservedStackAccess
    final boolean tryLockNanos(long nanos)
    @ReservedStackAccess
    protected final boolean tryRelease(int releases)

    protected final boolean isHeldExclusively()
    final ConditionObject newCondition()
    final Thread getOwner()
    final int getHoldCount()
    final boolean isLocked()
}

下面是一些重点的方法讲解。

tryLock

这个方法执行了一个不公平的尝试加锁操作:

    @ReservedStackAccess
    final boolean tryLock() {
        Thread current = Thread.currentThread();    // 获取当前线程
        int c = getState();                         // 从 AQS 中获取状态
        if (c == 0) {                               // 当前锁的状态为未被持有
            if (compareAndSetState(0, 1)) {         // CAS 更新状态为加锁状态 1
                setExclusiveOwnerThread(current);   // 设置当前持有的线程
                return true;                        // 获取锁成功,return true
            }
        } else if (getExclusiveOwnerThread() == current) {  // 如果当前持有锁的线程是当前线程
            if (++c < 0) // overflow                        // c 即是状态也是计数器,可重入计数 + 1
                throw new Error("Maximum lock count exceeded");
            setState(c);                                    // 更新状态
            return true;                                    // 重入成功,return true
        }
        return false;                                       // 尝试获取锁失败。
    }

为什么说它是不公平的,因为这个方法没有按照公平等待原则,让等待时间最久的线程优先获取锁资源。

initialTryLock

这是一个抽象方法,用来在 lock 前执行初始化工作。

lock

    @ReservedStackAccess
    final void lock() {
        if (!initialTryLock())
            acquire(1);
    }

先根据 initialTryLock() 进行判断,然后调用 acquire(1) ,acquire 方法在 AQS 中:

    public final void acquire(int arg) {
        if (!tryAcquire(arg))
            acquire(null, arg, false, false, false, 0L);
    }

这个方法会让当前线程去尝试获取锁资源,并忽略中断。通过调用 tryAcquire 至少一次来实现,如果失败,则去等待队列排队,可能会导致阻塞。

lockInterruptibly

    @ReservedStackAccess
    final void lockInterruptibly() throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (!initialTryLock())
            acquireInterruptibly(1);
    }

这个方法相当于在 lock 方法前首先进行了线程中断检查,如果没有被中断,也是通过 initialTryLock() 判断是否需要执行尝试获取锁的操作。与 lock 方法不同,这里调用的是 (1)

public final void acquireInterruptibly(int arg) throws InterruptedException {
    if (Thread.interrupted() || (!tryAcquire(arg) && acquire(null, arg, false, true, false, 0L) < 0))
        throw new InterruptedException();
}

对线程中断进行了检查,如果线程被中断则中止当前操作,至少调用 1 次 tryAcquire 尝试去获取锁资源。否则线程去队列排队,此方法可能会导致阻塞,直到调用 tryAcquire 成功或线程被中断。

tryLockNanos

        final boolean tryLockNanos(long nanos) throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            return initialTryLock() || tryAcquireNanos(1, nanos);
        }
    public final boolean tryAcquireNanos(int arg, long nanosTimeout)
        throws InterruptedException {
        if (!Thread.interrupted()) {
            if (tryAcquire(arg))
                return true;
            if (nanosTimeout <= 0L)
                return false;
            int stat = acquire(null, arg, false, true, true,
                               System.nanoTime() + nanosTimeout); // 多了一个超时时间
            if (stat > 0)
                return true;
            if (stat == 0)
                return false;
        }
        throw new InterruptedException();
    }

本质上调用 acquire ,多设置了一个 time 参数。

tryRelease

        @ReservedStackAccess
        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (getExclusiveOwnerThread() != Thread.currentThread())
                throw new IllegalMonitorStateException();
            boolean free = (c == 0); // c = 0 说明成功释放锁资源
            if (free)
                setExclusiveOwnerThread(null);
            setState(c);
            return free;
        }

可以看出,tryRelease 方法最终更新了 State ,进一步说明了 AQS 的实现,本质上都是通过原子 int 来表示同步状态的。

newCondition

    final ConditionObject newCondition() {
        return new ConditionObject();
    }

这里的 newCondition 返回的是 AQS 的内部类 ConditionObject 的实例。

Sync 中的方法与其含义:

NonfairSync 非公平锁

    static final class NonfairSync extends Sync {
        final boolean initialTryLock() {
            Thread current = Thread.currentThread();
            if (compareAndSetState(0, 1)) { // 比较并设置状态成功,状态0表示锁没有被占用
                setExclusiveOwnerThread(current); // 设置当前线程为持有锁的线程
                return true;
            } else if (getExclusiveOwnerThread() == current) { // 重入情况
                int c = getState() + 1;
                if (c < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(c);
                return true;
            } else
                return false;
        }
​
        protected final boolean tryAcquire(int acquires) {
            if (getState() == 0 && compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
    }

NonfairSync 实现了 initialTryLock() ,其中主要是为当前对象设置持有线程;如果是重入的情况,则 state 计数 + 1 。这个方法中的逻辑和 tryLock 方法十分相似,他们都是不公平的。每次尝试获取锁,都不是按照公平等待的原则,让等待时间最久的线程获得锁,所以这是不公平锁。

FairSync

    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        
        final boolean initialTryLock() {
            Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) { // 锁处于可用状态
                if (!hasQueuedThreads() && compareAndSetState(0, 1)) { // 查询是否有线程正在等待获取此锁
                    setExclusiveOwnerThread(current);
                    return true;
                }
            } else if (getExclusiveOwnerThread() == current) {
                if (++c < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(c);
                return true;
            }
            return false;
        }
        
        protected final boolean tryAcquire(int acquires) {
            if (getState() == 0 && !hasQueuedPredecessors() &&
                compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }
    }

公平锁依赖两个判断条件实现:

  • hasQueuedThreads 用来查询是否有其他线程正在等待获取此锁。
  • hasQueuedPredecessors 是用来查询是否有其他线程比当前线程等待的时间更长。

当存在其他线程等待时间更久时,当前线程的 tryAcquire 会直接返回 false 。

构造函数

ReentrantLock 有两个构造函数:

    public ReentrantLock() {
        sync = new NonfairSync();
    }​
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

其中一个带有 boolean 参数的构造方法,用来根据参数 fair 实现公平锁或非公平锁,无参构造方法默认实现是非公平锁。

核心属性和方法

private final Sync sync;

从构造方法中就可以看出,ReentrantLock 的 sync 属性,代表了锁的策略(公平 or 非公平)。

sync 是一个 Sync 类型的对象,继承自 AQS ,ReentrantLock 对外暴露的方法,内部实际上就是调用 Sync 对应的方法实现的:

public class ReentrantLock implements Lock, java.io.Serializable {
    // ...
    public void lock() {
        sync.lock();
    }
    public void lockInterruptibly() throws InterruptedException {
        sync.lockInterruptibly();
    }
    
    public boolean tryLock() {
        return sync.tryLock();
    }
    
    public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
        return sync.tryLockNanos(unit.toNanos(timeout));
    }
    
    public void unlock() {
        sync.release(1);
    }
    
    public Condition newCondition() {
        return sync.newCondition();
    }
    
    public int getHoldCount() {
        return sync.getHoldCount();
    }
    
    public boolean isHeldByCurrentThread() {
        return sync.isHeldExclusively();
    }
    
    public boolean isLocked() {
        return sync.isLocked();
    }
    
    public final boolean isFair() {
        return sync instanceof FairSync;
    }
    
    protected Thread getOwner() {
        return sync.getOwner();
    }
    // ... 
}

ReentrantLock 看起来就像是 Sync 的代理类,当调用 ReentrantLock 对外暴露的方法时,会根据 sync 对象的不同的类型调用不同的实现 。

比如,下图就是一个公平锁的调用过程:

ReentrantLock.lock -> 
FairSync.lock -> 
AQS.acquire -> 
FairSync.tryAcquire -> 
AQS.hasQueuedPredecessors -> AQS.setExclusiveOwnerThread

总结

ReentrantLock 实现了 Lock 接口,有三个内部类,其中 Sync 继承自 AQS ,而后两者继承自 Sync ,它们都继承了 AQS 的能力。本质上来说 ReentrantLock 的底层原理就是 AQS 。

在 Sync 的两个子类 FairSync 和 NonfairSync 分别是公平锁策略和非公平锁策略的实现,它们通过实现initialTryLock()方法中不同的逻辑(公平锁多了一个检查是否有其他等待线程的条件)。然后实现了不同的 tryAcquire(int acquires) ,从而在线程尝试获取锁时,执行不同的策略。

到此这篇关于Java 多线程并发ReentrantLock的文章就介绍到这了,更多相关Java ReentrantLock内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

Java 多线程并发ReentrantLock

下载Word文档到电脑,方便收藏和打印~

下载Word文档

猜你喜欢

Java多线程并发之ReentrantLock

这篇文章主要介绍了Java 多线程并发ReentrantLock,文中有非常详细的代码示例,对正在学习java的小伙伴们有非常好的帮助,需要的朋友可以参考下
2023-05-18

Java多线程并发ReentrantLock怎么使用

这篇文章主要介绍“Java多线程并发ReentrantLock怎么使用”的相关知识,小编通过实际案例向大家展示操作过程,操作方法简单快捷,实用性强,希望这篇“Java多线程并发ReentrantLock怎么使用”文章能帮助大家解决问题。背景
2023-07-02

Java多线程中ReentrantLock与Condition有什么用

这篇文章给大家分享的是有关Java多线程中ReentrantLock与Condition有什么用的内容。小编觉得挺实用的,因此分享给大家做个参考,一起跟随小编过来看看吧。一、ReentrantLock类1.1什么是reentrantlock
2023-05-30

如何实现 Java 多线程并发控制?(Java多线程并发控制怎样实现)

在Java编程中,多线程并发控制是一个重要的概念和技术。它允许程序同时执行多个线程,以提高程序的性能和响应性。然而,多线程并发也带来了一些挑战,如线程安全、竞态条件和死锁等。本文将介绍Java中实现多线程并发控制的方法和技巧。一、线程同步机制
如何实现 Java 多线程并发控制?(Java多线程并发控制怎样实现)
Java2024-12-13

Java多线程并发、并行、线程与进程实例分析

本篇内容介绍了“Java多线程并发、并行、线程与进程实例分析”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!一、并发与并行并发:指两个或多个事
2023-07-02

Java并发中ReentrantLock锁怎么用

这篇文章主要讲解了“Java并发中ReentrantLock锁怎么用”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“Java并发中ReentrantLock锁怎么用”吧!重入锁可以替代关键字
2023-06-21

理解Java多线程之并发编程

这篇文章主要介绍了理解Java多线程之并发编程的相关资料,需要的朋友可以参考下
2023-02-02

java ReentrantLock并发锁使用详解

这篇文章主要为大家介绍了java ReentrantLock并发锁使用详解,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2022-11-13

编程热搜

  • Python 学习之路 - Python
    一、安装Python34Windows在Python官网(https://www.python.org/downloads/)下载安装包并安装。Python的默认安装路径是:C:\Python34配置环境变量:【右键计算机】--》【属性】-
    Python 学习之路 - Python
  • chatgpt的中文全称是什么
    chatgpt的中文全称是生成型预训练变换模型。ChatGPT是什么ChatGPT是美国人工智能研究实验室OpenAI开发的一种全新聊天机器人模型,它能够通过学习和理解人类的语言来进行对话,还能根据聊天的上下文进行互动,并协助人类完成一系列
    chatgpt的中文全称是什么
  • C/C++中extern函数使用详解
  • C/C++可变参数的使用
    可变参数的使用方法远远不止以下几种,不过在C,C++中使用可变参数时要小心,在使用printf()等函数时传入的参数个数一定不能比前面的格式化字符串中的’%’符号个数少,否则会产生访问越界,运气不好的话还会导致程序崩溃
    C/C++可变参数的使用
  • css样式文件该放在哪里
  • php中数组下标必须是连续的吗
  • Python 3 教程
    Python 3 教程 Python 的 3.0 版本,常被称为 Python 3000,或简称 Py3k。相对于 Python 的早期版本,这是一个较大的升级。为了不带入过多的累赘,Python 3.0 在设计的时候没有考虑向下兼容。 Python
    Python 3 教程
  • Python pip包管理
    一、前言    在Python中, 安装第三方模块是通过 setuptools 这个工具完成的。 Python有两个封装了 setuptools的包管理工具: easy_install  和  pip , 目前官方推荐使用 pip。    
    Python pip包管理
  • ubuntu如何重新编译内核
  • 改善Java代码之慎用java动态编译

目录