ReentrantLock 核心原理

最新推荐文章于 2024-05-16 16:41:45 发布
最新推荐文章于 2024-05-16 16:41:45 发布
阅读量825 收藏 2
点赞数 1
分类专栏： Java并发 文章标签： java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44129618/article/details/129903318
版权
本文详细介绍了Java中的公平锁与非公平锁的概念和原理，特别是在ReentrantLock中的实现。公平锁确保线程按等待顺序获取锁，而非公平锁则允许线程尝试插队。ReentrantLock通过构造函数可以选择公平或非公平模式。此外，文章还讨论了可中断锁与不可中断锁的区别，以及可重入锁的实现机制，强调了ReentrantLock的可重入性和线程安全特性。
摘要由CSDN通过智能技术生成

目录


Lock 接口源码如下： 

public interface Lock {

	// 加锁，没有获得锁的线程会到同步队列中阻塞排队
    void lock();
    
    // 加锁（可中断）：当获得锁的线程被中断时，中断异常将会抛出，同时锁会被释放
    void lockInterruptibly() throws InterruptedException;
    
    // 尝试获得锁，如果锁没有被占用，则返回true，否则返回false
    boolean tryLock();

	// 带有超时等待时间的锁，如果超时时间到了，依旧没有获得锁的话，返回 false
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    
    // 解锁
    void unlock();
	
	// 得到新的Condition
    Condition newCondition();
}

1. 公平锁与非公平锁

1.1 公平锁原理

公平锁的核心就是对争抢锁的所有线程都是公平的，在多线程并发环境中，每个线程在抢占锁的过程中，都会首先检查锁维护的等待队列。如果等待队列为空，或者当前线程为等待队列中的第一个线程，则当前线程会获取到锁，否则，当前线程会加入等待队列的尾部，然后队列中的线程会按照先进先出的规则按顺序获取锁资源。
image.png

1.2 ReentrantLock 中的公平锁

ReentrantLock 叫做可重入互斥锁。
可重入的意思是同一个线程可以对同一个共享资源重复的加锁或释放锁，互斥就是 AQS 中的排它锁的意思，只允许一个线程获得锁。
ReentrantLock 类本身实现了 Lock 接口。

ReentrantLock 实现了公平锁的机制，在类中，提供了一个带有 boolean 类型参数的构造方法：

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

**在这个构造方法中，如果传入的参数为 true，则会创建一个 FairSync 对象并复制给成员变量 sync，此时线程获取的锁就是公平锁。**FairSync 是 ReentrantLock 类中提供的一个表示公平锁的静态内部类。源码如下所示：

static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

FairSync 类中的 lock 方法会调用 AQS 的 acquire 方法，AQS 的 acquire 方法又会调用 tryAcquire 方法，而 AQS 中的 tryAcquire 方法实际上是基于子类实现的，因此，此时调用的还是 FairSync 类的方法。原因是 FairSync 类继承了 Sync 类，而 Sync 类直接继承了 AQS。（这个地方有些绕，建议大家自己打开 IDE，具体看一下方法之间是如何进行调用的）
Sync 类是 ReentrantLock 类中的一个静态抽象内部类，源码如下：

    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        abstract void lock();

        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        protected final boolean isHeldExclusively() {
        
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

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

        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

        final boolean isLocked() {
            return getState() != 0;
        }

        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }

回到 FairSync 类中，FairSync 类的 tryAcquire 方法会通过 hasQueuedPredecessors 方法判断队列中是否存在后继节点，如果队列中存在后继节点，并且当前线程未占用锁资源，则 tryAcquire 方法会返回 false，当前线程会进入等待队列的尾部进行排队。流程如下：
image.png

1.3 非公平锁原理

非公平锁的核心就是对抢占锁的所有线程都是不公平的，在多线程并发环境中，每个线程在抢占锁的过程中都会先直接尝试抢占锁，如果抢占锁成功，就继续执行程序的业务逻辑，如果抢占失败，就会进入等待队列中排队。
公平锁与非公平锁的核心区别就在于排队的处理上，非公平锁在队列的队首位置可以进行一次插队操作，插队成功就可以获取到锁，插队失败就会像公平锁一样进入等待队列排队。在非公平锁模式下，可能出现某个线程在队列中等待时间过长而一直无法获取到锁的现象，这种现象叫作饥饿效应。
虽然非公平锁会产生饥饿效应，但是非公平锁比公平锁性能更优。
image.png

1.4 ReentrantLock 中的非公平锁

ReentrantLock 中默认实现的就是非公平锁，调用无参构造方法创建的对象就是非公平锁：

    public ReentrantLock() {
        sync = new NonfairSync();
    }

也可以调用有参构造，传入 false 参数创建非公平锁：

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

无论使用上面哪两种方式，都会创建一个 NonfairSync 类的对象并赋值给 ReentrantLock 类的成员变量 sync，此时创建的就是非公平锁。
NonfairSync 类也是一个静态内部类，源码如下：

    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

从上面的代码，我们可以看到，在非公平锁的加锁逻辑中，并没有直接将线程放入等待队列的尾部，而是先尝试将当前线程插入等待队列的头部，也就是先尝试获取锁资源。如果获取锁资源成功，则继续执行程序的业务逻辑。如果获取锁资源失败，则调用 AQS 的 acquire 方法获取锁资源。
同样，NofairSync 类继承了 Sync 类，而 Sync 类继承了 AQS ，所以，NonfairSync 类在加锁流程上的本质上，还是调用了 AQS 的入队出队操作。
AQS 的 acquire 方法会回调 NonfairSync 类中的 tryAcquire 方法，而在 NonfairSync 类的 tryAcquire 方法中，又会调用 Sync 类中的 nonfairTryAcquire 方法尝试获取锁，nonfairTryAcquire 方法源码如下：

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

同样，这块的逻辑，还是建议大家 IDE 一步一步看。
ReentrantLock 中非公平锁的加锁流程中方法调用的逻辑如图所示：
image.png

2. 可中断锁与不可中断锁

可中断锁是指多个线程抢占的过程中可以被中断的锁，不可中断锁指在多个线程抢占的过程中不可以被中断的锁。

2.1 可中断锁原理

ReentrantLock 就是可中断锁，支持在抢占锁的过程中中断锁。
在 Java 提供的 Lock 接口中，有两个方法抛出了 InterruptedException 异常，如下所示：

void lockInterruptibly() throws InterruptedException;

boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

这两个方法在加锁的过程中可以中断锁。具体的中断逻辑如下：

  1. lockInterruptibly 方法的中断逻辑：在抢占锁的过程中会处理由 Thread 类中的 interrupt 方法发出的中断信号，如果当前线程在抢占锁的过程中被中断，就会抛出异常并终止抢占锁的过程。
  2. tryLock(long time, TimeUnit unit) 方法中的中断逻辑：尝试在指定的时间内阻塞式的抢占锁，在抢占锁的过程中会处理由 Thread 类中的 interrupt 方法发出的中断信号，如果当前线程在抢占锁的过程中被中断，就会抛出异常并终止抢占锁的过程。

2.2 不可中断锁原理

不可中断锁指线程在抢占锁的过程中不能被中断。也就是说，线程在抢占不可中断锁时，如果抢占成功，则继续执行业务逻辑；如果抢占失败，则阻塞挂起。线程在阻塞挂起的过程中，不能被中断。synchronized 锁就是不可中断锁。

3. 可重入锁

可重入锁指一个线程可以反复对相同的资源加锁。
可重入锁表示一个线程能够对相同的资源重复加锁。也就是说，同一个线程能够多次进入使用同一个修饰锁的代码块，但需要注意的是，释放锁的次数需要与加锁的次数相同，才能保证真正释放了锁，伪代码如下：

        try {
            lock.lock();
            lock.lock();
            lock.lock();
            // ....
        } finally {
            lock.unlock();
            lock.unlock();
            lock.unlock();
        }

ReentrantLock 的内部类 Sync 的 nonfairTryAcquire 方法中，如下代码是 ReentrantLock 实现可重入锁的关键代码：

        	else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;

在上述代码中，在当前线程已经占有锁时，会判断当前线程是否是已经获取过锁的线程，则增加内部的状态计数，以此实现锁的可重入性。
当使用 ReentrantLock 对象解锁时，会先调用 AQS 的 relese 方法，而 AQS 的 release 方法又会调用 ReentrantLock 的内部类 Sync 的 tryRelease 方法，ReentrantLock 的内部类 Sync 的 tryRelease 源码如下：

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

在 ReentrantLock 的内部类 Sync 的 tryRelease 方法中，首先对状态计数减去传入的值，判断当前线程是否是已经获取到锁的线程，如果当前线程不是已经获取到锁的线程，则直接抛出 IllegalMonitorStateException 异常。然后定义一个是否成功释放锁的变量 free，默认值为 false。接下来，判断 state 状态计数的值是否减为 0。如果 state 状态计数的值已经减为 0，则说明当前线程已经完全释放锁，此时的锁处于空闲状态，将是否成功释放锁的变量 free 设置为 true，并将当前拥有锁的线程设置为 null。最后设置锁的状态标识，返回 free，结果会返回 true。
如果 state 状态计数的值没有减为 0，则说明当前线程并没有完全释放锁，此时的 free 变量为 false，返回 free，结果返回 false。
所以，在 ReentrantLock 中，可重入锁的加锁操作会累加状态计数，解锁操作会累减状态计数。Java 中的 synchronized 和 ReentrantLock 锁都实现了可重入性。

ReentrantLock非公平锁实现原理解读
JMU_software19的博客
12-17 894
概述 ReentrantLock基于AQS，在并发编程中可以实现公平锁和非公平锁来对共享资源进行同步，同时和synchronized一样，支持锁重入，除此之外，RenentrantLock更加灵活，支持实现更多丰富的功能。说到ReentrantLock根据它的中文名，翻译过来叫做，可重入锁。但是仅仅用可重入一个特性来描述ReentrantLock好像有点以偏概全，其公平锁，非公平锁的实现，以及condition的实现似乎都很重要。所以这也是编程人员命名的一个烦恼。 基于上...
并发编程系列——4Reentrantlock核心原理分析
Eclipse_2019的博客
10-13 510
Java中锁的类别；锁设计的核心思想；Reentrantlock与Synchronized的区别；Reentrantlock的使用；AQS的理解；Reentrantlock核心原理分析
ReentrantLock公平锁与非公平锁实现原理
峰回路转
09-02 3661
ReentrantLock公平锁与非公平锁的实现原理 ReentrantLock是J.U.C包下的一个类，默认是非公平的 public class ReentrantLock implements Lock, java.io.Serializable { // 内部类 private final Sync sync; public ReentrantLock() { // 默认使用非公平锁 sync = new NonfairSync(); }
Reentrant Lock非公平锁原理
最新发布
m0_62645012的博客
05-16 1242
ReentrantLock 有两种锁：公平锁和非公平锁。
图解ReentrantLock底层公平锁和非公平锁实现原理
BASK2311的博客
11-18 1038
1️⃣ 第一种情况，h!= t为false，说明head和tail节点都为null或者h和t都指向一个假节点head，这两种情况都说明了，此时的同步队列还没有初始化，简单点理解，就是在当前线程之前，还没有出现线程去抢占锁，因此，此时，锁是空闲的， 同时当前线程算上最早到来的线程之一（高并发场景下同一时刻可能存在N个线程同时到来），就可以通过CAS竞争锁。这里就呼应前文提到的非公平锁的概念——当N个线程去申请非公平锁，它们会直接去竞争锁，若能获取锁就直接占有，获取不到锁，再进入队列排队顺序等待获取锁。
ReentrantLock实现原理-非公平锁
小海编码日记
05-04 538
在线程间通信方式2一节中，我们了解了Lock，Condition和ReentrantLock，学习了简单使用Condition和RentrantLock完成线程间通信，从文章中我们了解到ReentrantLock是Lock接口的一个最常用的实现类，ReentrantLock是独占锁，独占锁的场景下又支持公平锁和非公平锁，那么在源码实现中，ReentrantLock继承关系，实现结构又是怎样的呢？
ReentrantLock的实现原理
盛夏温暖流年
09-30 4438
ReentrantLock 简介 ReentrantLock 实现了 Lock 接口，是一种可重入的独占锁。 相比于 synchronized 同步锁，ReentrantLock 更加灵活，拥有更加强大的功能，比如可以实现公平锁机制。 首先，先来了解一下什么是公平锁机制。 ReentrantLock 的公平锁机制 我们知道，ReentrantLock 分为公平锁和非公平锁，可以通过构造方法来指定具体类型： //默认非公平锁 public ReentrantLock() { sync =
7-ReentrantLock底层原理分析
weixin_45596022的博客
02-15 7151
一，Lock Lock 在 J.U.C 中是最核心的组件。 1，Lock实现 Lock 本质上是一个接口，它定义了释放锁和获得锁的抽象方法，定义成接口就意味着它定义了锁的一个标准规范，也同时意味着锁的不同实现。实现 Lock 接口的类有很多，以下为几个常见的锁实现。 ReentrantLock：表示重入锁，它是唯一一个实现了 Lock 接口的类。重入锁指的是线程在获得锁之后，再次获取该锁不需要阻塞，而是直接关联一次计数器增加重入次数。 ReentrantReadWriteLock：重入读写锁，它实现了 Re
揭秘ReentrantLock：AQS核心原理与获取锁机制
AQS（AbstractQueuedSynchronizer）是Java并发工具包（java.util.concurrent）中的一个核心抽象类，用于实现更高级的并发控制，如锁和条件变量。...理解AQS的底层原理对于深入学习和使用Java并发库至关重要。
JAVA多线程详解(三)：ReentrantLock实现原理与源码分析
ayugezhoubing的博客
06-28 496
刚学java的多线程通信时，往往只能知道在多线程访问共享资源时加上锁，保证多线程访问共享资源时的同步操作。利用ReentrantLock的lock()方法加锁，利用ReentrantLock的unlock()方法释放锁。那么加锁和释放锁的内部是怎么实现的呢？其源码解释的比较清晰。下面将从源码的整体架构和具体细节来分析ReentraLock的实现原理。由于大量使用了CAS操作，先介绍CAS的实现原理...
ReentrantLock的非公平锁AQS队列实现
TheOne的博客
09-24 1035
以下以ReentrantLock的NofaiySync分析AQS(又或者说CLH变种)的实现方式。 1、尝试获取资源 调用NofairSync的lock方法的时候，会先尝试对资源state加锁，失败的时候还会尝试获取锁。 final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread());
reentrantlock原理_ReentrantLock非公平锁与公平锁的实现
weixin_39883374的博客
12-01 230
ReentrantLock非公平锁与公平锁的实现在文章开始之前，大家复习一遍锁的分类：ReentrantLock是根据传入的参数来决定是否使用公平锁，默认使用非公平锁：公平锁/非公平锁当多个线程来取锁的时候，按照规则排队等锁即为公平锁，不按照规则排队的即为非公平锁, Synchronized就是一个典型的非公平锁，而ReentrantLock 是根据AQS来实现线程的一个调度达到公平锁...
12、ReentrantLock中的公平锁和非公平锁的原理
qq_26680031的博客
09-04 606
ReentrantLock ReentrantLock内部是通过AQS实现锁的功能，有公平锁和非公平锁两种实现。 公平锁，即锁的获取顺序按线程申请锁的先后顺序。 非公平锁，当一个线程t1申请锁时，锁刚好释放。即使已有其他线程在t1之前申请锁排队，线程t1还是会获取锁。这样减少了线程的等待唤醒的可能，减少上下文切换带来的开销。因为获取锁的顺序和申请顺序可能不一致所以叫非公平锁。 前置技能(先了...
ReentrantLock 实现原理（公平锁和非公平锁）
11-27 1103
使用 synchronized 来做同步处理时，锁的获取和释放都是隐式的，实现的原理是通过编译后加上不同的机器指令来实现。 而 ReentrantLock 就是一个普通的类，它是基于 AQS(AbstractQueuedSynchronizer)来实现的。 是一个重入锁：一个线程获得了锁之后仍然可以反复的加锁，不会出现自己阻塞自己的情况。 AQS 是 Java 并发包里实现锁、同步的一个重...
深入分析ReentrantLock公平锁和非公平锁的区别
热门推荐
m47838704的专栏
04-20 2万+
在ReentrantLock中包含了公平锁和非公平锁两种锁，通过查看源码可以看到这两种锁都是继承自Sync，而Sync又继承自AbstractQueuedSynchronizer，而AbstractQueuedSynchronizer又继承自AbstractOwnableSynchronizer，下面是类的继承关系图： 其中AbstractOwnableSynchronizer是提供了设置占...
ReentrantLock的非公平锁和公平锁的实现原理
jsj13263690918的博客
11-26 1292
非公平锁 因为之前已经分析过AQS，ReentranLock是利用一个实现了AQS的NonfairSync来获取非公平锁。所以只需关注NonfairSync的tryAcquire的实现。       获取锁（nonfairTryAcquire方法定义在Sync内部类中）   获取锁成功分为两种情况，第一个if判断AQS的state是否等于0，表示锁没有人占有。接着，hasQueu...
ReentrantLock实现原理深入探究
weixin_34290631的博客
11-24 556
前言 这篇文章被归到Java基础分类中，其实真的一点都不基础。网上写ReentrantLock的使用、ReentrantLock和synchronized的区别的文章很多，研究ReentrantLock并且能讲清楚ReentrantLock的原理的文章很少，本文就来研究一下ReentrantLock的实现原理。研究ReentrantLock的实现原理需要比较好的Java基础以及阅读代码的能力，有...
ReentrantLock原理
周小东
10-14 190
ReentrantLock原理 ReentrantLock主要利用CAS+AQS队列来实现。它支持公平锁和非公平锁，两者的实现类似。 CAS：Compare and Swap，比较并交换。CAS有3个操作数：内存值V、预期值A、要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。该操作是一个原子操作，被广泛的应用在Java的底层实现中。在Java中，CAS主要是由sun.misc.Unsafe这个类通过JNI调用CPU底层指令实现 ReentrantLock主要利用CAS+
ReentrantLock中公平锁与非公平锁的实现原理
gs_albb的博客
03-29 1301
在java中，一般的锁实现都要借助队列同步器AbstractQueuedSynchronizer,继承它并重写其指定的方法，随后调用同步器提供的模板方法，模板方法最终会再调用到自己重写的方法。tryAcquire(int acquires)就是其中的一个抽象方法，需要重写。 ReentrantLock公平锁与非公平锁的实现原理区别就是抽象方法tryAcquire的实现不同。公平锁的同步器tryA...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

SuZhan7710

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

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

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

打赏作者

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

抵扣说明：

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

余额充值