死磕多线程（7）-深入理解AQS（源码解析）

最新推荐文章于 2024-10-16 10:13:45 发布

快跑程序猿

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量194

点赞数

文章标签：队列多线程 java 分布式并发编程

本文链接：https://blog.csdn.net/qq_43511657/article/details/104381503

版权

本篇文章将对AQS进行深入了解，并对其源码进行解析
对AQS源码的分析主要基于以下两个方面：
1.独占锁的获取（acquire）与释放（release）
2.独占锁的特性：
响应中断IockInterrutibly（）-acquireInterruptibly（）
超时获取锁tryLock（long time,TimeUnit unit)-doAcquireNanos(arg,nanos Timeout)

一、独占锁的获取
ReetrantLock源码分析：

final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
//lock方法使用CAS来尝试将同步状态改为1，如果成功则将同步状态持有线程置为当前线程。否则将调用AQS提供的acquire()方法

acquire()源码：获取同步状态

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
// tryAcquire再次使用CAS尝试获取同步状态，
//  若成功方法直接返回，当前线程置为持有锁线程
//  若再次尝试失败，调用addWaiter()

addWaiter（）源码－将当前线程封装为Node节点后尾插入队列

private Node addWaiter(Node mode) {
    //将当前线程以指定模式（独占式，共享式）封装为Node节点
    Node node = new Node(Thread.currentThread(), mode);
    //拿到当前同步队列的尾节点
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        //将当前节点使用CAS尾插入同步队列
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
／／当前队列为空或ＣＡＳ尾插失败
    enq(node);
    return node;
}
//1. 当前同步队列的尾节点为null，调用方法enq()插入;
//2. 当前队列的尾节点不为null，则采用尾插入（compareAndSetTail（）方法）的方式入队。

enq（）：

在当前线程是第一个加入同步队列时，调用compareAndSetHead(new Node())方法，完成链式队列的头结点的初始化；
自旋不断尝试CAS尾插入节点直至成功为止。

private Node enq(final Node node) {
    ／／死循环－不断自旋
    for (;;) {
        ／／拿到尾节点
        Node t = tail;
        ／／当前队列为空
        if (t == null) { // Must initialize
        ／／完成队列的初始化操作，Lazy-load
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            ／／不断将当前节点使用ＣＡＳ尾插入同步队列中直到成功为止
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

问题：在同步队列中的节点（线程）如何保证自己能够有机会获得独占式锁-排队获取锁
方法：acquireQueued（）
1.如果当前节点的前驱节点是头节点，并且能够获得同步状态的话，当前线程能够获得锁该方法执行结束退出；
2. 获取锁失败的话，先将节点状态设置成SIGNAL，然后调用LookSupport.park方法使得当前线程阻塞。

final boolean acquireQueued(final Node node, int arg) {
    ／／设置失败状态，初始化为true
    boolean failed = true;
    try {
        ／／设置中断状态，默认为false
        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)
        ／／将当前节点置为取消状态，node．waitStatus＝１
            cancelAcquire(node);
    }
}

节点从同步队列获取同步状态的前提条件：只有当前驱节点为头节点时，线程才有机会获取同步状态
if (p == head && tryAcquire(arg)) ----> setHead(node)

private void setHead(Node node) {
head = node;
node.thread = null;
node.prev = null;
}
 ／／将当前节点置为头节点

获取同步状态示意图：
在这里插入图片描述
当获取锁失败的时候会调用shouldParkAfterFailedAcquire()方法和parkAndCheckInterrupt()方法首先调用shouldParkAfterFailedAcquire(Node pred, Node node)中的 compareAndSetWaitStatus(pred, ws, Node.SIGNAL)尝试将前驱节点状态改为Node.SIGNAL，表示当前线程被阻塞:

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    ／／获取前驱节点状态
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)　　－１
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
         ／／表示应该将当前节点阻塞
        return true;
        ／／前驱节点被取消
    if (ws > 0) {
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
         ／／一直向前找到节点状态不是取消状态的节点
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * waitStatus must be 0 or PROPAGATE.  Indicate that we
         * need a signal, but don't park yet.  Caller will need to
         * retry to make sure it cannot acquire before parking.
         */
         ／／将前驱节点状态置为single，－１
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

直至将状态改为SIGNAL，执行parkAndCheckInterrupt():

private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);//阻塞当前线程
return Thread.interrupted();
}

整体流程：
在这里插入图片描述
具体实现方法：

二、独占锁的释放

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

unparkSuccessor()：唤醒距离头部节点最近的一个非空节点（最大可能保证公平）

private void unparkSuccessor(Node node) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    int ws = node.waitStatus;
    //
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {
        s = null;
        //当头节点的下一个节点为空时
        //从同步队列尾部开始一直找到距离头节点最近的一个非空节点
        //从而进一步可以佐证获得锁的过程是一个FIFO（先进先出）的过程。
        //------------------------------------------------------------
        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.线程获取锁失败，将线程调用addWaiter()封装成Node进行入队操作。addWaiter()中方法enq()完成对同步队列的头结点初始化以及CAS尾插失败后的重试处理。
2.入队之后排队获取锁的核心方法acquireQueued(),节点排队获取锁是一个自旋过程。当且仅当当前节点的前驱节点为头结点并且成功获取同步状态时，节点出队并且该节点引用的线程获取到锁。否则，不满足条件时会不断自旋将前驱节点的状态置为SIGNAL而后调用LockSupport.park()将当前线程阻塞。
3.释放锁时会唤醒后继节点(后继节点不为null)

四、可中断获取锁
可响应中断式锁可调用方法lock.lockInterruptibly();而该方法其底层会调用AQS的acquireInterruptibly方法，源码为：

public final void acquireInterruptibly(int arg)
throws InterruptedException {
//--------------------------------------------------------
    //增加了对中断状态的判断
    //如果检测线程中断状态改变，抛出中断异常后方法直接退出
if (Thread.interrupted())
throw new InterruptedException();
//-------------------------------------------------------------
if (!tryAcquire(arg))
// 线程获取锁失败
doAcquireInterruptibly(arg);
}

在获取同步状态失败后就会调用doAcquireInterruptibly方法：

private void doAcquireInterruptibly(int arg)
throws InterruptedException {
// 将节点插入到同步队列中
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
// 获取锁出队
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
//---------------------------------------------------------
//线程被阻塞时若检测到中断则抛出中断异常后退出
// 线程中断异常
throw new InterruptedException();
//-----------------------------------------------------------
}
} finally {
if (failed)
cancelAcquire(node);
public final void acquireInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (!tryAcquire(arg))
// 线程获取锁失败
doAcquireInterruptibly(arg);
}}
}

获取锁响应中断原理与acquire()几乎一样，唯一的区别是当parkAndCheckInterrupt返回true时即线程阻塞时该线程被中断，代码抛出被中断异常。

五、超时等待式获取锁（在中断获取锁的基础上增加超时功能）
boolean tryLock(timeout,TimeUnit) throws InterruptedException)该方法的本质是调用AQS中的模板方法tryAcquireNanos()：

public final boolean tryAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
return tryAcquire(arg) ||
// 实现超时等待的效果
doAcquireNanos(arg, nanosTimeout);
}

最终是靠doAcquireNanos方法实现超时等待的效果，

private boolean doAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
//-----------------------------------------------------------
    //传入时间小于0 方法直接退出，线程获取锁失败
if (nanosTimeout <= 0L)
return false;
// 1.根据超时时间和当前时间计算出截止时间
final long deadline = System.nanoTime() + nanosTimeout;
//-----------------------------------------------------------
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
// 2.当前线程获得锁出队列
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return true;
}
//------------------------------------------------------------
// 3.1 再次计算截至时间-当前时间值
nanosTimeout = deadline - System.nanoTime();
// 3.2 已经超时返回false，直接退出
if (nanosTimeout <= 0L)
return false;
// 3.3 线程阻塞等待，在超时时间内仍未被唤醒，线程退出
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
// 3.4 线程被中断抛出被中断异常
if (Thread.interrupted())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}

超时等待获取锁tryAcquireNanos(),该方法在三种情况下会返回:
I.在超时时间内，当前线程成功获取到锁。
II.当前线程在超时时间内被中断。
III.超时时间结束，仍未获取到锁，线程退出返回false。
超时获取锁逻辑与可中断获取锁基本一致，唯一区别在于获取锁失败后，增加了一个时间处理，如果当前时间超过截止时间，线程不再等待，直接退出，返回false。否则将线程阻塞置为等待状态排队获取锁。

整体逻辑图：
在这里插入图片描述