【锁】【JUC】可重入锁/AQS队列--ReentrantLock源码分析

最新推荐文章于 2022-11-26 20:30:28 发布

wj-1024

最新推荐文章于 2022-11-26 20:30:28 发布

阅读量2.9k

点赞数 4

分类专栏：锁 JUC 源码分析文章标签： java 队列多线程

本文链接：https://blog.csdn.net/aaa_bbb_ccc_123_456/article/details/103638698

版权

源码分析同时被 3 个专栏收录

17 篇文章 3 订阅

订阅专栏

JUC

10 篇文章 2 订阅

订阅专栏

锁

7 篇文章 0 订阅

订阅专栏

1.可重入锁/AQS队列

之前有写过一篇关于锁的笔记：【锁】公平锁/非公平锁/可重入锁/递归锁/自旋锁/独占锁/共享锁/读写锁
里面关于重入锁，特别AQS队列并没有提到，故借学习ReentrantLock源码几下这篇笔记。

2. ReentrantLock源码分析

2.1 类图

今天啰嗦一些，我们一步一步看：

idea找到JUC包里面的ReentrantLock，右键如图：

-打开类图：
我们可以看到ReentrantLock里面有一个Sync抽象类，两个内部静态类NonfairSync和FairSync
其中NonfairSync和FairSync是ReentrantLock公平锁和非公平锁的实现
而Sync我们右键打开它的类图：
Sync继承于AbstractQueuedSynchronizer
而AbstractQueuedSynchronizer里面维护了一个以Node为节点的AQS队列。
AQS队列，就是是ReentrantLock的核心。

2.2 AQS队列

追根溯源，AQS队列是由AbstractQueuedSynchronizer维护
而AbstractQueuedSynchronizer由继承于AbstractOwnableSynchronizer
我们先看AbstractOwnableSynchronizer源码：

public abstract class AbstractOwnableSynchronizer
    implements java.io.Serializable {
    
    protected AbstractOwnableSynchronizer() { }
    private transient Thread exclusiveOwnerThread;

    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

exclusiveOwnerThread从名字就能看出来独家拥有线程，也就是独占模式锁的拥有者。
而AQS定义两种资源共享方式：

1,Exclusive（独占，只有一个线程能执行，ReentrantLock使用该模式）

2,Share（共享，多个线程可同时执行，Semaphore/CountDownLatch使用该模式）。

AQS队列底层其实就是链表，而在AbstractQueuedSynchronizer中链表节点是有内部类Node来充当，在Node里有这么两行代码：

        /** Marker to indicate a node is waiting in shared mode */
        static final Node SHARED = new Node();
        /** Marker to indicate a node is waiting in exclusive mode */
        static final Node EXCLUSIVE = null;

exclusiveMarker to indicate a node is waiting in shared mode
共享模式：CountDownLatch使用该模式，详细可见:【JUC】CountDownLatch源码分析
Marker to indicate a node is waiting in exclusive mode
独占模式：ReentrantLock使用该模式,今天我们聊的就是这个
再看一下AbstractQueuedSynchronizer的核心成员：

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {

    private static final long serialVersionUID = 7373984972572414691L;
  
    protected AbstractQueuedSynchronizer() { }

   //队列节点
    static final class Node {
        /** Marker to indicate a node is waiting in shared mode */
        static final Node SHARED = new Node();
        /** Marker to indicate a node is waiting in exclusive mode */
        static final Node EXCLUSIVE = null;
        
        /** waitStatus value to indicate thread has cancelled */ 线程已经被取消，该状态的节点不会再次阻塞。
		static final int CANCELLED =  1;
		/** waitStatus value to indicate successor's thread needs unparking */ 线程需要去被唤醒
		static final int SIGNAL    = -1;
		/** waitStatus value to indicate thread is waiting on condition */ 线程正在唤醒等待条件
		static final int CONDITION = -2;
		/**
		 * waitStatus value to indicate the next acquireShared should //线程的共享锁应该被无条件传播
		 * unconditionally propagate
		 */
		static final int PROPAGATE = -3;
        
        //上面四个值就是下面变量waitStatus的值
        volatile int waitStatus;
        //前一个节点
        volatile Node prev;
        //下一个节点
        volatile Node next;
        //当前节点代表的线程
        volatile Thread thread;
        /**
        *等待节点的后继节点。如果当前节点是共享的，那么这个字段是一个SHARED常量，也就是说节点类型（独占和共享）和
        *等待队列中的后继节点共用一个字段。（注：比如说当前节点A是共享的，那么它的这个字段是shared，也就是说在这个等
        *待队列中，A节点的后继节点也是shared。如果A节点不是共享的，那么它的nextWaiter就不是一个SHARED常量，即是独
        *占的。
        */
        Node nextWaiter;
}
    //头结点
    private transient volatile Node head;
     //尾节点
    private transient volatile Node tail;
    //状态值
    private volatile int state;

如果了解CLH队列的话你会感觉眼熟，因为AQS队列就是它的一个变体，至于CLH队列是什么，看这里：【锁】自旋锁-MCS/CLH队列
AbstractQueuedSynchronizer的这些成员中，volatile修饰的state是重点，volatile关键字保证了线程间可见性。具体可见:【JUC】volatile关键字相关整理
ReentrantLock加锁记录就保存在state中，state默认为0，表示没有被加锁，每当线程请求一个锁，state加1，state=1表示加锁成功，state>1表示锁重入，详细后面看源码聊。
在多线程并发请求锁时，采用CAS修改state的值，修改成功则获取锁成功，修改失败则加入到AQS等待队列尾部，至于什么是CAS,可见：【JUC】 Java中的CAS。
另一个要注意的AbstractQueuedSynchronizer里Node中的状态属性waitStatus，它默认为零，还有四个值见上面Node代码,它的值会被后置结点在获取锁失败后阻塞前修改，用于提醒你在释放锁后去唤醒它，具体详细情况后面源码聊。
AQS结构图
AQS队列的头结点并不关联任何线程，他是一个默认的Node节点。

2.3 开始撸代码

先看构造函数：

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

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

当参数fair=true时，创建的是公平锁fair=false时，创建的是非公平锁，啥也不填默认创建的是非公平锁，至于啥是公平和非公平，见:【锁】公平锁/非公平锁/可重入锁/递归锁/自旋锁/独占锁/共享锁/读写锁。

2.3.1先搞默认的非公平锁，NonfairSync类的lock方法：

static final class NonfairSync extends Sync {
        final void lock() {
            if (compareAndSetState(0, 1))      //1
                setExclusiveOwnerThread(Thread.currentThread());  //2
            else
                acquire(1);  //3
        }

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

public final void acquire(int arg) {//5
        if (!tryAcquire(arg) &&  //6
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))   //7
            selfInterrupt();   //8
    }

总体流程如下：

1,CAS原子性的修改AbstractQueuedSynchronizer#state的值，由0改为1，成功则说明当前线程加锁成功.

2，设置AbstractOwnableSynchronizer#exclusiveOwnerThread的值为当前线程，表示当前锁的拥有者是当前线程。

3,如果1中修改失败，则进入acquire(1)。申请1个state，acquire方法中首先尝试获取锁tryAcquire()，如果获取失败，则将当前线程以独占模式Node.EXCLUSIVE加入等待队列尾部（addWaiter方法）。

4,acquireQueued()：以独占无中断模式获取锁，这个方法会一直无限循环，直到获取到资源或者被中断才返回。如果等待过程中被中断则返回true。这里有自旋锁的意思，加入队列中的线程，不断的重试检测是否可以执行任务。

接下来一个一个方法撸源码：

tryAcquire

tryAcquire的具体实现是在NonfairSync类中，然后调用其父类Sync 中的nonfairTryAcquire（）方法。

static final class NonfairSync extends Sync {
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}
    
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();//:1、获取volatile int state的值
    if (c == 0) {//2：state=0表示当前可以加锁
        if (compareAndSetState(0, acquires)) {//CAS将state设置为acquires的值
            setExclusiveOwnerThread(current);//设置当前拥有锁的线程
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {//当前锁的拥有者线程是currentThread
        int nextc = c + acquires;//将state累加上acquires
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);//设置state的值。由于这里只有获取锁的线程才能执行，所以不会出现并发，不需要额外的加锁处理
        //这也是ReentrantLock为什么是可重入锁的原因，同一个线程加多次锁（lock.lock）也就是给state的值累加而已。
        return true;
    }
    return false;//当前锁的拥有者线程不是currentThread，直接返回false，也就是获取锁失败
}

nonfairTryAcquire的实现：如果当前没有锁，那么加锁。如果已经有了锁，那么看看当前锁的拥有者线程是不是currentThread，是则累加state的值，不是则返回失败。
所以，使用ReentrantLock时，线程获得锁的标记是在state上的，state=0表示没有被加锁，state=1表示加锁成功，state>1表示锁重入。

addWaiter和enq

按照指定模式（独占还是共享）将节点添加到等待队列。

private Node addWaiter(Node mode) {
    Node node = new Node(Thread.currentThread(), mode);
    //1、首先尝试以快速方式添加到队列末尾
    Node pred = tail;//pred指向现有tail末尾节点
    if (pred != null) {
    //新加入节点的前一个节点是现有AQS队列的tail节点
        node.prev = pred;
      	//CAS原子性的修改tail节点
        if (compareAndSetTail(pred, node)) {    
            //修改成功，新节点成功加入AQS队列，pred节点的next节点指向新的节点
            pred.next = node;
            return node;
        }
    }
    //2、pred为空，或者修改tail节点失败，
    //则走enq方法将节点插入队列
    enq(node);
    return node;
}
private Node enq(final Node node) {
    for(;;) {//CAS
        Node t = tail;
        if (t == null) { 
        // 必须初始化。这里是AQS队列为空的情况。
        //通过CAS的方式创建head节点，并且tail和head都指向
        //同一个节点。
            if (compareAndSetHead(new Node()))
            //注意这里初始化head节点，并不关联任何线程！！
                tail = head;
        } else {
        //这里变更node节点的prev指针，并且移动tail指针指向node，
        //前一个节点的next指向新插入的node
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

上面addWaiter方法的第一行代码new Node(Thread.currentThread(), mode);，会创建一个node对象，该对象的重要属性值初始化为：

nextWaiter = Node.EXCLUSIVE; // Node.EXCLUSIVE值为null
thread = Thread.currentThread();
waitStatus = 0;// 默认是0

addWaiter首先会以快速方式将node添加到队尾，如果失败则走enq方法。失败有两种可能，一个是tail为空，也就是AQS为空的情况下。另一是compareAndSetTail失败，也就是多线程并发添加到队尾，此时会出现CAS失败。
注意enq方法，在t==null时，首先创建空的头节点，不关联任何的线程，nextWaiter和thread变量都是null。

acquireQueued

tryAcquire失败没有获取到锁，addWaiter加入了AQS等待队列，进入acquireQueued方法中，acquireQueued方法以独占无中断模式获取锁，这个方法会一直无限循环，直到获取到资源或者被中断才返回。

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;//是否获取到资源
    try {
        boolean interrupted = false;//是否中断
        for (;;) {
            //获取前一个节点
            final Node p = node.predecessor();

			//如果当前node节点是第二个节点，紧跟在head后面，
			//那么tryAcquire尝试获取资源
            if (p == head && tryAcquire(arg)) {                
                setHead(node);//获取锁成功，当前节点成为head节点
                p.next = null; // 目的：辅助GC
                failed = false;
                return interrupted;//返回是否中断过
            }
            
            //当shouldParkAfterFailedAcquire返回成功，
            //也就是前驱节点是Node.SIGNAL状态时，
            //进行真正的park将当前线程挂起，并且检查中断标记，
            //如果是已经中断，则设置interrupted =true。
            //如果shouldParkAfterFailedAcquire返回false，
            //则重复上述过程，直到获取到资源或者被park。
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);//添加AQS失败，取消任务
    }
}

//前面讲过，head节点不与任何线程关联，他的thread是null，
//当然head节点的prev肯定也是null
private void setHead(Node node) {
    head = node;
    node.thread = null;
    node.prev = null;
}

//在Acquire失败后，是否要park中断
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws= pred.waitStatus;//获取到上一个节点的waitStatus
    if (ws == Node.SIGNAL)//前面讲到当一个节点状态时SIGNAL时，
    //他有责任唤醒后面的节点。所以这里判断前驱节点是SIGNAL状态，
    //则可以安心的park中断了。
        return true;
    if (ws > 0) {
        /*
         * 过滤掉中间cancel状态的节点
         * 前驱节点被取消的情况（线程允许被取消哦）。向前遍历，
         * 直到找到一个waitStatus大于0的（不是取消状态或初始状态）
         * 的节点，该节点设置为当前node的前驱节点。
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * 修改前驱节点的WaitStatus为Node.SIGNAL。
         * 明确前驱节点必须为Node.SIGNAL，当前节点才可以park 
         * 注意，这个CAS也可能会失败，因为前驱节点的WaitStatus状态
         * 可能会发生变化
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

//阻塞当前线程
//park并且检查是否被中断过
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

cancelAcquire

acquireQueued方法在出现异常时，会执行cancelAcquire方法取消当前node的acquire操作。

private void cancelAcquire(Node node) {
    if (node == null)
        return;

    node.thread = null;

    // 跳过中间CANCELLED状态的节点
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;

    Node predNext = pred.next;

    // 将node设置为CANCELLED状态
    node.waitStatus = Node.CANCELLED;

    // 如果当前节点是tail节点，则直接移除
    if (node == tail && compareAndSetTail(node, pred)) {
        compareAndSetNext(pred, predNext, null);
    } else {
        int ws;
        if (pred != head &&
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {//如果pred不是head节点并且是SIGNAL 状态，
            //或者可以设置为SIGNAL 状态，
            //那么将pred的next设置为node.next，也就是移除当前节点
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);
        } else {
            unparkSuccessor(node);//唤醒node的后继节点
        }

        node.next = node; // help GC
    }
}
private void unparkSuccessor(Node node) {
    //如果waitStatus为负数，则将其设置为0（允许失败）
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    //唤醒当前节点后面的节点。通常是紧随的next节点，
    //但是当next被取消或者为空，则从tail到node之间的所有节点，
    //往后往前查找直到找到一个waitStatus <=0的节点，将其唤醒unpark
    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);
}

总结一下：

1、设置thread变量为空，并且设置状态为canceled

2、跳过中间的已经被取消的节点

3、如果当前节点是tail节点，则直接移除。否则：

4、如果其前驱节点不是head节点并且（前驱节点是SIGNAL状态，或者可以被设置为SIGNAL状态），那么将当前节点移除。否则通过LockSupport.unpark()唤醒node的后继节点

获取非公平锁过程总结
在这里插入图片描述
2.3.2 公平锁加锁

公平锁与非公平锁的区别就在于这里，在tryAcquire方法中，首先会检查是否有任何线程等待获取的时间长于当前线程。

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;
        }
public final boolean hasQueuedPredecessors() {
        // The correctness of this depends on head being initialized
        // before tail and on head.next being accurate if the current
        // thread is first in queue.
        Node t = tail; // Read fields in reverse initialization order
        Node h = head;
        Node s;
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

就是看看AQS队列是否为空，如果不为空，那么head的下一个节点是否为当前请求的线程，如果不是，说明前面有其他线程排队，当前线程应该加入等待队列中。

2.4 最后，释放锁

 public void unlock() {
        sync.release(1);
    }
    
public final boolean release(int arg) {
    if (tryRelease(arg)) {//尝试释放资源  state
        Node h = head;
        if (h != null && h.waitStatus != 0)//如果AQS不为空，并且头节点的waitStatus不是0,之前在shouldParkAfterFailedAcquire方法内设置成了-1
            unparkSuccessor(h);//unpark后继节点
        return true;
    }
    return false;
}

//这里不需要加锁，因为只有获取锁的线程才会来释放锁，
//所以这里直接将state减去releases即可
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;
}

private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    //
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        for (Node t = tail; t != null && t != node; t = t.prev)//注意这里是从AQS队列的尾节点开始查找的，
        //找到最后一个 waitStatus<=0 的那个节点，将其唤醒。
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        LockSupport.unpark(s.thread);
}

彻底释放完资源（state=0）后，会去唤醒AQS队列中的一个等待节点，该节点查找顺序为从AQS队列的尾节点开始查找的，找到最后一个 waitStatus<=0 的那个节点，通过LockSupport.unpark将其唤醒。

【完】

wj-1024

关注

4
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
【锁】【JUC】可重入锁/AQS队列--ReentrantLock源码分析

1.重入锁/AQS队列之前有写过一篇关于锁的笔记：【锁】公平锁/非公平锁/可重入锁/递归锁/自旋锁/独占锁/共享锁/读写锁里面关于重入锁，特别AQS队列并没有提到，故借学习ReentrantLock源码几下这篇笔记。2. ReentrantLock源码分析2.1 类图今天啰嗦一些，我们一步一步看：idea找到依赖的jdk下面rt.jar里面JUC包里面的ReentrantLock右...
复制链接

扫一扫