ReentrantLock源码详解：AQS原理分析

最新推荐文章于 2024-09-21 10:47:48 发布

紫罗兰盛开

最新推荐文章于 2024-09-21 10:47:48 发布

阅读量1.3w

点赞数 6

分类专栏：高并发文章标签： r语言 java 开发语言

本文链接：https://blog.csdn.net/wwwvipp/article/details/118995557

版权

高并发专栏收录该内容

6 篇文章 1 订阅

订阅专栏

ReentrantLock类图

基于jdk1.8的源码分析
在这里插入图片描述

说明：本篇文章以公平锁（FairSync）说明，非公平锁的原理和公平锁大部分雷同，很多代码是提取在抽象类共用的，实现更简单，搞懂了公平锁的源码及原理，即可理解非公平锁

加锁过程

执行流程图

请添加图片描述

源码解析

从ReentrantLock的lock方法跟进来，选择公平锁的实现，发现底层调用的是java.util.concurrent.locks.AbstractQueuedSynchronizer#acquire方法

    /**
     *    主要做三件事  1.tryAcquire：尝试通过CAS获取一次锁，详情可见下面源码分析
     *      2.addWaiter：将当前线程加入到储存等待获取锁的线程的双向链表中
     *      3.acquireQueued:通过自旋的方式，判断当前队列节点是否可以获取锁
     */
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

下面我们按照执行顺序，一个个的分析，首先看java.util.concurrent.locks.ReentrantLock.FairSync#tryAcquire方法

		protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            // 等于0，表示当前没有线程占用锁；否则表示有线程占用锁
            if (c == 0) {
                // 1.判断队列中是否有线程在排队；2.如果没有，则通过CAS尝试修改state状态，修改成功就获得锁
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 判断正在占用锁的线程是否当前线程，是的话，state+1,用来保证可重入性
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

再看下java.util.concurrent.locks.AbstractQueuedSynchronizer#addWaiter方法

	// 将新节点和当前线程关联并且入队列
	private Node addWaiter(Node mode) {
        // 基于当前线程创建一个节点,设置关联线程和模式(独占 or 共享)
        Node node = new Node(Thread.currentThread(), mode);
        // 获取队列的尾节点
        Node pred = tail;
        if (pred != null) {
            // 如果尾节点不为空,说明队列已经初始化过,则把当前节点的前一个节点指向尾节点
            node.prev = pred;
            // 同时当前节点作为新的尾节点
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        // 尾节点为空,说明队列还未初始化,需要初始化head节点并入队新节点
        enq(node);
        return node;
    }

再看下java.util.concurrent.locks.AbstractQueuedSynchronizer#acquireQueued方法

    // 通过自旋的方式，判断当前队列节点是否可以获取锁
    final boolean acquireQueued(final Node node, int arg) {
    	// 标记是否成功获取锁
        boolean failed = true;
        try {
          	//标记线程是否被中断过
            boolean interrupted = false;
            // 开启自旋，一直等到当前节点的前一个节点是头部节点，并且获取锁成功
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    // 此时把当前节点设置为头节点
                    setHead(node);
                    // 原来的头节点废弃掉
                    p.next = null; // help GC
                    // 失败状态标记为否
                    failed = false;
                    // 退出自旋
                    return interrupted;
                }
                // 如果获取锁失败，则当前线程阻塞，继续保持自旋
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

acquireQueued方法自旋图解
请添加图片描述
解析下内部方法shouldParkAfterFailedAcquire的源码

/**
 * 判断当前线程获取锁失败之后是否需要挂起.
 */
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //前驱节点的状态
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        // 前驱节点状态为signal,返回true
        return true;
    // 前驱节点状态为CANCELLED
    if (ws > 0) {
        // 从队尾向前寻找第一个状态不为CANCELLED的节点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 将前驱节点的状态设置为SIGNAL
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}
  
/**
 * 挂起当前线程,返回线程中断状态并重置
 */
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

线程入队后成为新的尾节点，此时必须保证他前面的节点（即之前的尾节点）等待状态waitStatus是SIGNAL，SIGNAL表示当前一个节点保存的线程对象获取到锁后会唤醒改节点。所以shouldParkAfterFailedAcquire会先判断当前节点的前驱是否状态符合要求，若符合则返回true，然后调用parkAndCheckInterrupt，将自己挂起。如果不符合，再看前驱节点是否>0(CANCELLED)，若是那么向前遍历直到找到第一个符合要求的前驱，若不是则将前驱节点的状态设置为SIGNAL。
整个流程中，如果前驱结点的状态不是SIGNAL，那么自己就不能安心挂起，需要去找个安心的挂起点，同时可以再尝试下看有没有机会去尝试竞争锁。

最终队列可能会如下图所示

请添加图片描述

释放锁的过程

执行流程图

请添加图片描述

源码解读

从ReentrantLock的unlock方法跟进来，发现底层调用的是
java.util.concurrent.locks.AbstractQueuedSynchronizer#release方法

    public final boolean release(int arg) {
    // 尝试释放锁，如果失败，说明已经重入了，则返回释放失败
        if (tryRelease(arg)) {
            Node h = head;
            // 如果队列中头节点不为空，且等待状态不为0，则说明队列中有线程在等待，需要释放该线程的锁
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

java.util.concurrent.locks.ReentrantLock.Sync#tryRelease方法源码解读

        protected final boolean tryRelease(int releases) {
            // 当前锁状态减1
            int c = getState() - releases;
            // 当前线程不等于持有锁的线程，则直接抛出异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            // 状态为0，则表示锁释放成功
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            // 重新设置状态
            setState(c);
            return free;
        }

java.util.concurrent.locks.AbstractQueuedSynchronizer#unparkSuccessor方法解读

    // 唤醒节点的后继节点(如果存在的话)。
    private void unparkSuccessor(Node node) {
        /*
         * 如果状态是消极的(即，可能需要信号)，试着在信号发出的预期中明确。如果此操作失败，或者状态通过等待线程改变，也没有关系。
         */
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        /*
         * 帮助后继的节点释放锁，后继节点通常就是下一个节点。但如果被取消或明显为null，则从尾部往回遍历，以找到实际的未取消的后继对象
         */
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }