ReentrantLock实现原理分析

最新推荐文章于 2024-10-02 22:15:56 发布

ting说你跳

最新推荐文章于 2024-10-02 22:15:56 发布

阅读量840

点赞数 1

分类专栏： Java 文章标签： Java 重入锁 AQS CAS

本文链接：https://blog.csdn.net/sted_zxz/article/details/78394671

版权

Java 专栏收录该内容

32 篇文章 2 订阅

订阅专栏

类图

ReentrantLock相关类图：

这里写图片描述

AbstractOwnableSynchronizer类保持和获取独占线程。
AbstractQueuedSynchronizer，继承自AbstractOwnableSynchronizer，简称AQS，基于FIFO(First Input First Output)队列的实现。以虚拟队列的方式管理线程的锁获取与锁释放，以及各种情况下的线程中断。提供了默认的同步实现，但是获取锁和释放锁的实现定义为抽象方法，由子类实现。目的是使开发人员可以自由定义获取锁以及释放锁的方式。
Sync是ReentrantLock的内部抽象类，继承自AbstractQueuedSynchronizer，实现了简单的获取锁和释放锁。NonfairSync和FairSync分别表示“非公平锁”和“公平锁”，都继承于Sync，并且都是ReentrantLock的内部类。
ReentrantLock实现了Lock接口的lock-unlock方法，根据fair参数决定使用NonfairSync还是FairSync。

AQS

ReentrantLock实现的前提就是AbstractQueuedSynchronizer，简称AQS，是java.util.concurrent的核心，CountDownLatch、FutureTask、Semaphore、ReentrantLock等都有一个内部类是这个抽象类的子类。

Node

Node是AQS的内部类，是对每一个访问同步代码的线程的封装。不仅包括了需要同步的线程，而且也包含了每个线程的状态，比如等待解除阻塞，等待条件唤醒，已经被取消等等。同时Node还关联了前驱和后继，即prev和next。

多个Node连接起来成为了虚拟队列（因为不存在真正的队列容器将每个元素装起来所以说是虚拟的，我把它称为release队列，意思是等待释放），其实就是一个有头有尾的双向链表结构：

这里写图片描述

state

是AQS的一个成员变量，用来记录锁的持有情况：

没有线程持有锁的时候，state为0。
当某个线程获取锁时，state的值增加，具体增加多少开发人员可自定义，默认为1，表示该锁正在被一个线程占有。
当某个已经占用锁的线程再次获取到锁时，state再增长，此为重入锁。
当占有锁的线程释放锁时，state也要减去当初占有时传入的值，默认为1。

多个线程竞争锁的时候，state必须通过CAS进行设置，这样才能保证锁只能有一个线程持有。

Sync

NonfairSync和FairSync分别表示“非公平锁”和“公平锁”，都继承于Sync，并且都是ReentrantLock的内部类。

我们来看NonfairSync获取锁的代码：

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

        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;
        }

还有FairSync获取锁的代码：

        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;
        }