AQS独占锁、Reentrantlock源码底层实现

AQS独占锁、Reentrantlock源码

管程

java同步的设计思想

• 管程：管理共享变量以及对共享变量的操作过程，让他们支持并发
• 互斥：同一时刻只允许一个线程访问共享资源
• 同步：线程之间如何通信、协作

管程发展至今，出现过三种不同的管程模型：Hasen模型、Hoare模型和HESA模型。现在广泛应用的是HESA模型

首先入口处有一个共享变量，就是一个标记，当前是否加锁了，如果加锁成功就进行下面的过程，如果加锁失败就进入入口等待队列中等待下一次加锁、这里就实现了互斥性

上图中间部分有两个条件变量，这其实就是生产者与消费者的两个条件变量，生产者生成完和消费者消费完，调用等待方法后是进入到条件变量等待队列中。当被唤醒后需要进入入口等待队列中去重新进行竞争锁

条件变量等待队列要实现的核心方法就是wait() notify() notifyALl()

了解了上面的知识之后，那我们如何实现一把独占锁？

1. 定义一个标识变量，用来判断是否加锁，如果没有加锁才可以往下走，如果没有加锁成功那么就进入到一个等待队列中

   • 这其中有多个线程修改标识变量的过程，那么我们就可以使用CAS来保证一个时刻只有一个线程修改成功

   • 当获取到锁的线程执行完之后，我们就需要唤醒等待队列中的线程，这里就用到了等待唤醒机制

     唤醒某一个线程可以使用LockSupport.park()/unpark(thread)，使用案例如下所示：

     // 线程A先调用park()方法，等待
     LockSupport.park();
     
     // 线程B调用unpark()方法唤醒，下面thread是线程A的对象
     Thread thread;
     LockSupport.unpark(thread);
     

2. 条件变量的等待队列无非也就是构建队列、入队、出队。这些都是公共逻辑

对于队列的入队出队、修改CAS的这些公共逻辑，我们可以使用模板模式，完全可以去定义一个抽象类，抽取公共方法。再具体的方法就交给子类自己去实现

AQS原理分析

简介

AQS的全程：AbstractQueuedSynchronizer

java.util.concurrent包中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，而这些行为的抽象就是基于AbstractQueuedSynchronizer（简称AQS）实现的，AQS是一个抽象同步框架，可以用来实现一个依赖状态的同步器。

JDK中提供的大多数的同步器如Lock, Latch, Barrier等，都是基于AQS框架来实现的

AQS的特性：

• 阻塞等待队列
• 共享/独占
• 公平/非公平
• 可重入
• 允许中断

核心结构

内部维护了一个标识位的变量

// 表示资源的可用状态
private volatile int state;

State三种访问方式：

protected final int getState() {
    return state;
}

protected final void setState(int newState) {
    state = newState;
}

/**
 * CAS方式
 */
protected final boolean compareAndSetState(int expect, int update) {
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

定义了两种资源访问方式：

• Exclusive-独占，只有一个线程能执行，如ReentrantLock
• Share-共享，多个线程可以同时执行，如Semaphore/CountDownLatch

AQS的获取锁对象的acquire()方法、释放锁的release()方法

// 首先调用我们子类重写的tryAcquire（）方法，如果没有获取到则调用acquireQueued()方法进行等待队列的入队操作
public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}


// 在unparkSuccessor()方法中就会调用LockSupport.unpark()方法唤醒入口等待队列中的线程
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

AQS的等待唤醒机制，是基于AbstractQueuedSynchronizer中的内部类ConditionObject来实现的

AQS实现时主要实现以下几种方法：

• isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。
• tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false。
• tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。
• tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
• tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

此时如果再问让我们自己实现一个独占锁，那么就直接继承AQS类，这样对于static状态的维护、未竞争到锁进入入口等待队列中就不用我们自己实现了。然后在子类中自己写加锁与解锁的逻辑

AQS定义两种队列

• 同步等待队列： 主要用于维护获取锁失败时入队的线程。
• 条件等待队列： 调用await()的时候会释放锁，然后线程会加入到条件队列，调用signal()唤醒的时候会把条件队列中的线程节点移动到同步队列中，等待再次获得锁。

AQS 定义了5个队列中节点状态：

1. 值为0，初始化状态，表示当前节点在sync队列中，等待着获取锁。
2. CANCELLED，值为1，表示当前的线程被取消；
3. SIGNAL，值为-1，表示当前节点的后继节点包含的线程需要运行，也就是unpark；
4. CONDITION，值为-2，表示当前节点在等待condition，也就是在condition队列中；
5. PROPAGATE，值为-3，表示当前场景下后续的acquireShared能够得以执行；

同步等待队列

AQS当中的同步等待队列也称CLH队列，CLH队列是Craig、Landin、Hagersten三人发明的一种基于双向链表数据结构的队列，是FIFO先进先出线程等待队列，Java中的CLH队列是原CLH队列的一个变种,线程由原自旋机制改为阻塞机制。

AQS 依赖CLH同步队列来完成同步状态的管理：

• 当前线程如果获取同步状态失败时，AQS则会将当前线程已经等待状态等信息构造成一个节点（Node）并将其加入到CLH同步队列，同时会阻塞当前线程
• 当同步状态释放时，会把首节点唤醒（公平锁），使其再次尝试获取同步状态。
• 通过signal或signalAll将条件队列中的节点转移到同步队列。（由条件队列转化为同步队列）

条件等待队列

AQS中条件队列是使用单向列表保存的，用nextWaiter来连接:

• 调用await()方法阻塞线程；
• 当前线程存在于同步队列的头结点，调用await()方法进行阻塞（从同步队列转化到条件队列）

ReentrantLock底层源码

关注的问题：

• 公平锁与非公平锁
• 可重入锁
• 并发场景下入队和出队操作是如何设计的
• 线程竞争锁失败入队阻塞逻辑实现
• 释放锁的线程唤醒阻塞线程出队竞争锁的逻辑实现

公平锁与非公平锁

首先从构造方法中看出，Reentrantlock默认是非公平锁，可以通过传一个boolean值来决定公平与非公平

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

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

我们现在再来看看lock()方法，这是非公平锁NonfairSync对象中的lock()方法

static final class NonfairSync extends Sync {
    final void lock() {
        // 这里首先就会调用cas  将static从0变为1
        // 如果此时又来了一个新的线程，可能刚好前一个线程释放锁，这里一个新的线程就加锁成功。就相当于插队
        if (compareAndSetState(0, 1))
            // 这里还会设置一个属性exclusiveOwnerThread= thread，独占的线程为当前线程，这也是后续可重入锁的判断依据
            setExclusiveOwnerThread(Thread.currentThread());
        else
            // 如果没有插队成功就老老实实去走正常获取锁的逻辑
            acquire(1);
    }
    ...
}

假如现在这是线程1，此时它最先竞争能够修改成功，然后将独占线程的属性设置为线程1。

然后线程2再来cas修改，修改不成功，就会走到else逻辑中调用acquire(1)方法

public final void acquire(int arg) {
    // 插队，去尝试获取锁，如果获取不到就调用acquireQueued()方法进入阻塞队列中
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

尝试获取锁逻辑如下，这里会进入到非公平锁的尝试获取锁逻辑中

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    // 这个时候线程1已经事先将state改为了1，所以这里目前获取不到锁。
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 这里会判断独占线程exclusiveOwnerThread属性是不是为当前线程thread对象，这是可重入锁的逻辑，后续详细介绍这里
    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;
}

此时线程2尝试获取锁会获取不到，返回false，然后就会进入阻塞队列的逻辑中，那么就会有创建队列，入队的操作，后续详细介绍。

我们接下来再看如果是公平锁是什么样子的

static final class FairSync extends Sync {

    final void lock() {
        // 这里就直接调用加锁的方法，只会加锁一次，而非公平锁刚进lock()方法就会去插队获取一次锁
        acquire(1);
    }
    ....
}

可重入锁

我们接下来再来看看尝试获取锁方法的下半部分逻辑

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 这里会判断独占线程exclusiveOwnerThread属性是不是为当前线程thread对象
    else if (current == getExclusiveOwnerThread()) {
        // c是当前state的值，acquires的值是1   这里每次都会+1
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        // 然后把相加后的结果重新赋值给state变量
        setState(nextc);
        return true;
    }
    return false;
}

入口等待队列的入队操作

线程1已经获取到了锁，将status改为了1，现在又来了一个线程2来获取锁

public final void acquire(int arg) {
    // 尝试获取锁如果失败，那么就会调用acquireQueued()方法了
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

Node.EXCLUSIVE表示独占；Node.SHARED表示共享锁

先调用addWaiter()，将当前线程封装为一个Node对象，插入到双向链表的尾部

private Node addWaiter(Node mode) {
    // 首先会创建一个新节点
    Node node = new Node(Thread.currentThread(), mode);
    // 尾结点，刚开始队列都没有，tail节点也是null，所以下面这个if目前还不会执行
    // 如果tail节点不为null，就直接把刚刚新建的节点插入到链表的尾部，并维护好prev和next两个指针
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) { // 如果这一次CAS失败了，那么就会进入到enq()方法中循环CAS入队
            pred.next = node;
            return node;
        }
    }
    // 然后就直接进入到此方法中进行入队
    enq(node);
    return node;
}

当前创建的节点对象如下，独占方式下主要的属性就是waitStatus和thread这两个

enq(Node node)方法实现如下，如果尾结点为null则进行链表的初始化，如果不为null则循环CAS入队操作。

private Node enq(final Node node) {
    // 这里就写了一个循环，一定要入队之后才会跳出循环
    for (;;) {
        Node t = tail;
        if (t == null) { // 如果尾节点为null就必须要进行初始化，就创建一个新节点为头节点。然后把头节点指针和尾结点指针都指向这个新节点
            if (compareAndSetHead(new Node())) // head头节点代表当前已经获取到锁的线程
                tail = head;
        } else {
            // 如果尾结点不为null，那么就把最新的Node节点对象插入到链表的尾部，并维护好这个节点和尾结点的双向指令
            node.prev = t;
            // 把tail指针移动到新插入的node节点上
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

入队后阻塞线程

线程入队之后，我们还需要调用这个线程的LockSupport.park()方法让它进入等待状态，接下来再回到刚开始的入口方法

public final void acquire(int arg) {
    // 尝试获取锁如果失败，那么就会调用acquireQueued()方法了
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

现在addWaiter()方法已经执行完入队操作了，接下来就会调用acquireQueued()方法

// 这个方法的实现逻辑就是一个死循环中，判断是否为头节点的下一个节点 并且尝试获取锁。否则就进入等待状态
// 在进入等待状态之前会先将前一个节点的awaitStatus改为-1，当被唤醒后又进行循环尝试获取锁
final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            // 返回当前节点的前一个节点p
            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 {
        // try语句段中会响应其他线程的中断标识，然后抛异常这里捕获，再执行cancelAcquire()方法。当然响应中断这里不是重点
        if (failed)
            cancelAcquire(node);
    }
}

shouldParkAfterFailedAcquire(Node pred, Node node)方法逻辑如下，

// 将前一个节点的awaitStatus改为-1
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        // 前一个节点的waitStatus为-1就表示当前节点可以被唤醒
        return true;
    if (ws > 0) {
        // 前一个节点被取消了，直接跳过前一个节点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 初始状态，前一个节点waitStatus为0，所以上面两个条件都不满足，直接调用下面的方法采用CAS的方式将0改为-1
        // 目的就是在阻塞当前线程之前，我要做一些准备工作，以便之后可以被唤醒
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

这里就返回false了，再回到上一个acquireQueued()方法中，又会进行一次循环，又会进入到shouldParkAfterFailedAcquire(Node pred, Node node)方法中，这次前一个节点的waitStatus为-1了，所以这次返回了true。

那么就会调用parkAndCheckInterrupt()方法，最终调用了LockSupport.park(this);进入了等待

private final boolean parkAndCheckInterrupt() {
    // 调用park()方法 使当前线程进入等待状态
    LockSupport.park(this);
    return Thread.interrupted();
}

如果此时又来了一个线程3来加锁，那么就会变成下图所示的情况：

释放锁、唤醒后继节点

目前线程2进入了等待状态，线程1继续执行业务逻辑，然后调用lock.unlock();方法释放锁

public void unlock() {
    sync.release(1);
}

public final boolean release(int arg) {
    // 释放锁
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            // 唤醒
            unparkSuccessor(h);
        return true;
    }
    return false;
}

先执行tryRelease()释放锁

protected final boolean tryRelease(int releases) {
    // 首先把state-1，如果没有重入的话，结果就变为0了
    int c = getState() - releases;
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 如果为0就把exclusiveOwnerThread属性变为null
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    // 然后直接更新0，这里就不需要进行CAS操作了，因为只有一个线程会执行
    setState(c);
    return free;
}

当state变为0后，就调用unparkSuccessor()方法唤醒后继节点

private void unparkSuccessor(Node node) {
    /*
     * 头节点的waitStatus如果小于0，那么就CAS修改状态再变为0
     */
    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);
}

出队操作

目前线程1已经释放了锁，并且唤醒了线程2，那么就回到线程2进入等待状态的位置

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            // 当被唤醒后，线程2又执行一遍循环
            final Node p = node.predecessor();
            // 唤醒后，下面这个if就满足条件了，然后当前节点就充当head节点，之前的头节点就出队
            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);
    }
}