reentrantlock原理_ReenranctLock释放锁的AQS底层原理

第二章  JDK源码剖析-并发篇

第 11 节

reentrantLock(3)

前两节你应该掌握了ReentrantLock加锁成功和加锁失败入队的核心逻辑，是如何通过AQS中的3个组件做到的。今天来我们看下：

• ReentrantLock中，当线程释放锁时的逻辑

释放锁的过程及源码剖析

   目前经过线程1、线程2使用ReentrantLock.lock()后的结果如下：

   

线程2入队等待，线程1持有锁，state=1，owner是线程1，队列中元素是线程2，队列是由Node节点组成的双向链表，头结点为空，队列具体情况如下：

此时假设线程1调用了unlock()方法，进行释放锁，会做哪些事情呢？

首先我们来看一下释放的代码：

    public void unlock() {

        sync.release(1);

    }

非常简单，还是使用Sync组件(AQS)来释放锁。release()方法

     public final boolean release(int arg) {

        if (tryRelease(arg)) {

            Node h = head;

            if (h != null && h.waitStatus != 0)

                unparkSuccessor(h);

            return true;

        }

        return false;

    }

核心分为了2步：

1)tryRelease方法，释放state和owner变量

2)unparkSuccessor方法，唤醒队列元素

分别来看一下，首先释放变量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;

}

这个方法逻辑很清晰，当前线程是线程1，state=1，入参releases是1，表示释放一次锁。很明显，state减1后变为0，会将owner也置为空，表示当前没有线程持有锁了，之后设置state为0结束。

整个过程如下图所示:

修改了owner和state两个组件的值后，第二步就是唤醒队列等待的线程了。

public final boolean release(int arg) {

    if (tryRelease(arg)) {

        Node h = head;

        if (h != null && h.waitStatus != 0)

            unparkSuccessor(h);

        return true;

    }

    return false;

}

首先释放成功锁后，使用了h指针指向了当前队列的头部，判断一下队列中是否有等待的元素，注意对头元素waitStatus不能是0，如果是0，说明队列只有一个空节点，队列中没有等待元素。因为入队元素后会将头结点的waitStatus改成-1，SIGNAL。

接着进入了unpartSuccessor方法。从名字看就是恢复在h节点之后挂起的线程。(PS:JDK源码里面总会出现一些语义相近的词语，比如first-last,head-tail,successor-predecessor,prev-next，其实都是表示前后的意思，是等价的，这点大家要清楚。)

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)

            if (t.waitStatus <= 0)

                s = t;

    }

    if (s != null)

        LockSupport.unpark(s.thread);

}

node就是入参h，head节点，首先把head节点waitStatus从-1改为0。

接着s=node.next表示的就是线程2排队的Node，s不为空，执行了LockSupport.unpark(s.thread); 将线程2进行了唤醒。

最后整个方法返回，release返回true表示释放锁成功。如下图所示：

 

此时之前被挂起的线程2，还记得吗？就是线程2曾经执行了LockSupport.park(t)的操作，线程被挂起，代码会hang在那一行等待。

private final boolean parkAndCheckInterrupt() {

    LockSupport.park(this);

    return Thread.interrupted();

}

线程2就会接着执行，只要线程2没被打断过，返回的肯定是false，以下的if条件不会成立。

 if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())

接着回到for循环，重新进行tryAcquire操作，线程2再次尝试获取锁，此时假设没有别的线程过来加锁。线程2自然就会获取锁，设置state=1，owner=线程2了。

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

    }

}

上面整个释放锁的过程可以总结如下图：

 

从一张长图总结加锁和释放锁全流程

为了让大家更好的掌握ReentrantLock的AQS原理。这里给大家总结了一下。

首先可以把原理用一句话简单的讲：假设有两个线程同时进行获取锁的操作，只能有一个获取成功，另一个会进入一个队列等待。底层是结合了state、owner，Node队列AQS的3个组件配合起来做到的。

ReentrantLock核心加锁和释放流程可以总结为如下一张长图：