ReentrantLock的复习总结，赶紧收藏！！

最新推荐文章于 2023-03-05 16:03:56 发布

XuTengRui

最新推荐文章于 2023-03-05 16:03:56 发布

阅读量185

点赞数 1

分类专栏： Java学习文章标签：锁 java 并发编程

本文链接：https://blog.csdn.net/blackarmand/article/details/118566842

版权

Java学习专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前言

在JAVA高并发编程中，为了保证线程安全，我们通常会给线程加锁保证线程安全，但是通常如果你仅仅知道加锁就够了话，那你可能只是入门小学生，作为一个伟大的资深程序猿，肯定要对一个技术刨根问题，不然怎么在圈子里混下去....接下来咱们就来一起总结下面试常会问的ReentrantLock重入锁概念。

锁的分类

下面是博主以前总结的关于锁的思维导图，赶紧点赞收藏吧！！！

ReentrantLock的自我介绍

Hi~程序猿们大家好，我是你们要找的ReentrantLock。

我是锁这个大家庭里的一员，属于可重入锁哦，这个一定要记住了，结合上面的家族图片看出，如果能在线程中取同一把锁才叫可重入锁。我和咱们的老大哥synchronized有点像，但是我更小巧灵活哦。

ReentrantLock底层基于AbstractQueuedSynchronizer(简称AQS)实现，这里对AQS的底层不多做阐述哦，下期会对AQS做更深度的讲解，赶紧关注我吧，哥哥们~

AbstractQueuedSynchronizer抽象类定义了一套多线程访问共享资源的同步模板，解决了实现同步器时涉及的大量细节问题，能够极大地减少实现工作，用大白话来说，AbstractQueuedSynchronizer为加锁和解锁过程提供了统一的模板函数，只有少量细节由子类自己决定。

好了，我的自我介绍完了，如果想深入了解我，请接着往下看哦~

ReentrantLock结构组成

首先从ReentrantLock的组成架构开始入手：

从上图可以看出ReentrantLock继承了Lock接口，ReentrantLock围绕着Lock接口实现其中的函数，然后创建了Sync对象，Sync则继承了AQS，实现了非公平锁和公平锁两个子类。下面我们对Sync组件和NonfairSync和FairSync子类做逐一深入了解。

Sync

Sync逻辑都比较简单，实现了A Q S类的释放资源（tryRelease），然后抽象了一个获取锁的函数让子类自行实现（lock），再加一个偏心的函数nonfairTryAcquire。下面放一张tryRelease流程图，在后续的NonfairSync、FairSync都会有全面的流程。

NonfairSync

现在我们把视线转移到NonfairSync，在ReentrantLock中支持两种获取锁的策略，分别是非公平策略与公平策略，NonfairSync就是非公平策略。

在说非公平策略前，先简单的说下A Q S（AbstractQueuedSynchronizer）流程，A Q S为加锁和解锁过程提供了统一的模板函数，加锁与解锁的模板流程是，获取锁失败的线程，会进入CLH队列阻塞，其他线程解锁会唤醒CLH队列线程，如下图所示（简化流程）

上图中，线程释放锁时，会唤醒CLH队列阻塞的线程，重新竞争锁，要注意，此时可能还有非CLH队列的线程参与竞争，所以非公平就体现在这里，非CLH队列线程与CLH队列线程竞争，各凭本事，不会因为你是CLH队列的线程，排了很久的队，就把锁让给你。

了解了什么是非公平策略，我们再来看看NonfairSync类定义

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

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1)) //设置state为1，代表资源获取成功
                //资源获取成功，设置当前线程为持有锁线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                //设置失败，代码获取资源失败，执行AQS获取锁模版流程
                acquire(1);
        }

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

NonfairSync继承Sync实现了lock函数，lock函数也非常简单，C A S设置状态值state为1代表获取锁成功，否则执行A Q S的acquire函数（获取锁模板），另外NonfairSync还实现了A Q S留给子类实现的tryAcquire函数（获取资源），这个被Sync宠幸的幸运儿，直接使用Sync提供的nonfairTryAcquire函数来实现tryAcquire，最后子类实现的tryAcquire函数在A Q S的acquire函数中被使用。

FairSync

所谓公平策略就是，严格按照CLH队列顺序获取锁，线程释放锁时，会唤醒CLH队列阻塞的线程，重新竞争锁，要注意，此时可能还有非CLH队列的线程参与竞争，为了保证公平，一定会让CLH队列线程竞争成功，如果非CLH队列线程一直占用时间片，那就一直失败（构建成节点插入到CLH队尾，由A S Q模板流程执行），直到时间片轮到CLH队列线程为止，所以公平策略的性能会更差。

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

        final void lock() {
            //设置state为1失败，代表获取资源失败，执行AQS获取锁模板流程，否获取资源成功
            acquire(1);
        }

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            //获取当前线程
            final Thread current = Thread.currentThread();
            //获取当前状态
            int c = getState();
            if (c == 0) {  //state==0表示资源可获取
                //1.hasQueuedPredecessors判断当前线程是不是CLH队列被唤醒的线程，如果是执行下一个步骤
                //2. 设置state为acquires，acquires传入的是1
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    //成功，设置当前持有锁的线程
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //如果state!=0,但是当前线程是持有锁线程，直接重入
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                //设置state状态，此处不需要cas，因为持有锁的线程只有一个 
                setState(nextc);
                return true;
            }
            return false;
        }
    }

其实我们不难发现FairSync流程与NonfairSync基本一致，唯一的区别就是在C A S执行前，多了一步hasQueuedPredecessors函数，这一步就是判断当前线程是不是CLH队列被唤醒的线程，如果是就执行CAS。

ReentrantLock特点

与synchronized相比具有如下特点：

可中断：synchronized只能等待同步代码块执行结束，不可以中断，而reentrantlock可以调用线程的interrupt方法来中断等待，继续执行下面的代码。
可以设置超时时间：调用lock.trylock()，如果没有设置等待时间的话，没获取到锁，将返回false
可以设置为公平锁：公平锁其实是为了解决饥饿问题，当一个线程由于优先级太低的时候，就可能没有办法获取到时间片
可以支持多个变量：类似于调用wait方法时，不满足条件的线程进入waitset队列等待CPU随机调度，支持多个变量表示支持多个类似自定义waitset，这样就可以指定对象来唤醒了。