Java并发编程-AQS

            pred.next = node;

            return node;

        }

    }

    //第一个入队的节点或者是尾节点后续节点新增失败时进入enq

    enq(node);

    return node;

}

private Node enq(final Node node) {

    for (;;) {

        Node t = tail;

        if (t == null) { // Must initialize

            //尾节点为空  第一次入队  设置头尾节点一致 同步队列的初始化

            if (compareAndSetHead(new Node()))

                tail = head;

        } else {

            //所有的线程节点在构造完成第一个节点后 依次加入到同步队列中

            node.prev = t;

            if (compareAndSetTail(t, node)) {

                t.next = node;

                return t;

            }

        }

    }

}

节点进入同步队列之后，就进入了一个自旋的过程，每个线程节点都在自省地观察，当条件满足，获取到了同步状态，就可以从这个自旋过程中退出，否则依旧留在这个自旋过程中并会阻塞节点的线程，代码如下：

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

    }

}

再来看看shouldParkAfterFailedAcquire和parkAndCheckInterrupt是怎么来阻塞当前线程的，代码如下：

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {

    //前驱节点的状态决定后续节点的行为

int ws = pred.waitStatus;

    if (ws == Node.SIGNAL)

        /\*前驱节点为-1 后续节点可以被阻塞

         \* 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 {

        /\*前驱节点是初始或者共享状态就设置为-1 使后续节点阻塞

         \* 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.

         \*/

        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);

    }

    return false;

}

private final boolean parkAndCheckInterrupt() {

    //阻塞线程

    LockSupport.park(this);

    return Thread.interrupted();

}

节点自旋的过程大致示意图如下，其实就是对图二、图三的补充。

图六  节点自旋获取队列同步状态

整个独占式获取同步状态的流程图大致如下：

图七  独占式获取同步状态

当同步状态获取成功之后，当前线程从acquire方法返回，对于锁这种并发组件而言，就意味着当前线程获取了锁。有获取同步状态的方法，就存在其对应的释放方法，该方法为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;

}

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;

        for (Node t = tail; t != null && t != node; t = t.prev)

            if (t.waitStatus <= 0)

                s = t;

    }

    if (s != null)

        //唤醒后续节点

        LockSupport.unpark(s.thread);

}

独占式释放是非常简单而且明确的。

总结下独占式同步状态的获取和释放：在获取同步状态时，同步器维护一个同步队列，获取状态失败的线程都会被加入到队列中并在队列中进行自旋；移出队列的条件是前驱节点为头节点且成功获取了同步状态。在释放同步状态时，同步器调用tryRelease方法释放同步状态，然后唤醒头节点的后继节点。

3.2 共享式同步状态的获取和释放

共享式同步状态调用的方法是acquireShared，代码如下：

public final void acquireShared(int arg) {

    //获取同步状态的返回值大于等于0时表示可以获取同步状态

    //小于0时表示可以获取不到同步状态  需要进入队列等待

    if (tryAcquireShared(arg) < 0)

        doAcquireShared(arg);

}

private void doAcquireShared(int arg) {

    //和独占式一样的入队操作

    final Node node = addWaiter(Node.SHARED);

    boolean failed = true;

    try {

        boolean interrupted = false;

        //自旋

        for (;;) {

            final Node p = node.predecessor();

            if (p == head) {

                int r = tryAcquireShared(arg);

                if (r >= 0) {

                    //前驱结点为头节点且成功获取同步状态 可退出自旋

                    setHeadAndPropagate(node, r);

                    p.next = null; // help GC

                    if (interrupted)

                        selfInterrupt();

                    failed = false;

                    return;

                }

            }

            if (shouldParkAfterFailedAcquire(p, node) &&

                parkAndCheckInterrupt())

                interrupted = true;

        }

    } finally {

        if (failed)

            cancelAcquire(node);

    }

}

private void setHeadAndPropagate(Node node, int propagate) {

    Node h = head; // Record old head for check below

    //退出自旋的节点变成首节点

    setHead(node);

    /\*

     \* Try to signal next queued node if:

     \*   Propagation was indicated by caller,

     \*     or was recorded (as h.waitStatus either before

     \*     or after setHead) by a previous operation

     \*     (note: this uses sign-check of waitStatus because

     \*      PROPAGATE status may transition to SIGNAL.)

     \* and

     \*   The next node is waiting in shared mode,

     \*     or we don't know, because it appears null

     \*

     \* The conservatism in both of these checks may cause

     \* unnecessary wake-ups, but only when there are multiple

     \* racing acquires/releases, so most need signals now or soon

     \* anyway.

     \*/

    if (propagate > 0 || h == null || h.waitStatus < 0 ||

        (h = head) == null || h.waitStatus < 0) {

        Node s = node.next;

        if (s == null || s.isShared())

            doReleaseShared();

    }

}

与独占式一样，共享式获取也需要释放同步状态，通过调用releaseShared方法可以释放同步状态，代码如下：

public final boolean releaseShared(int arg) {

    //释放同步状态

    if (tryReleaseShared(arg)) {

        //唤醒后续等待的节点

        doReleaseShared();

        return true;

    }

    return false;

}

private void doReleaseShared() {

    /\*

     \* Ensure that a release propagates, even if there are other

     \* in-progress acquires/releases.  This proceeds in the usual

     \* way of trying to unparkSuccessor of head if it needs

     \* signal. But if it does not, status is set to PROPAGATE to

     \* ensure that upon release, propagation continues.

     \* Additionally, we must loop in case a new node is added

     \* while we are doing this. Also, unlike other uses of

     \* unparkSuccessor, we need to know if CAS to reset status

     \* fails, if so rechecking.

     \*/

    //自旋

for (;😉 {

        Node h = head;

        if (h != null && h != tail) {

            int ws = h.waitStatus;

            if (ws == Node.SIGNAL) {

                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))

                    continue;            // loop to recheck cases

                //唤醒后续节点

unparkSuccessor(h);

            }

            else if (ws == 0 &&

                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))

                continue;                // loop on failed CAS

        }

        if (h == head)                   // loop if head changed

            break;

    }

}

unparkSuccessor方法和独占式是一样的。

4**、AQS应用**

AQS被大量的应用在了同步工具上。

ReentrantLock：ReentrantLock类使用AQS同步状态来保存锁重复持有的次数。当锁被一个线程获取时，ReentrantLock也会记录下当前获得锁的线程标识，以便检查是否是重复获取，以及当错误的线程试图进行解锁操作时检测是否存在非法状态异常。ReentrantLock也使用了AQS提供的ConditionObject，还向外暴露了其它监控和监测相关的方法。

ReentrantReadWriteLock：ReentrantReadWriteLock类使用AQS同步状态中的16位来保存写锁持有的次数，剩下的16位用来保存读锁的持有次数。WriteLock的构建方式同ReentrantLock。ReadLock则通过使用acquireShared方法来支持同时允许多个读线程。

Semaphore：Semaphore类（信号量）使用AQS同步状态来保存信号量的当前计数。它里面定义的acquireShared方法会减少计数，或当计数为非正值时阻塞线程；tryRelease方法会增加计数，在计数为正值时还要解除线程的阻塞。

CountDownLatch：CountDownLatch类使用AQS同步状态来表示计数。当该计数为0时，所有的acquire操作（对应到CountDownLatch中就是await方法）才能通过。

FutureTask：FutureTask类使用AQS同步状态来表示某个异步计算任务的运行状态（初始化、运行中、被取消和完成）。设置（FutureTask的set方法）或取消（FutureTask的cancel方法）一个FutureTask时会调用AQS的release操作，等待计算结果的线程的阻塞解除是通过AQS的acquire操作实现的。
SynchronousQueues：SynchronousQueues类使用了内部的等待节点，这些节点可以用于协调生产者和消费者。同时，它使用AQS同步状态来控制当某个消费者消费当前一项时，允许一个生产者继续生产，反之亦然。
除了这些j.u.c提供的工具，还可以基于AQS自定义符合自己需求的同步器。
AQS就学习到这，如果有描述不当的地方，还请留言交流。了解了AQS后下一步准备详细学习基于AQS的工具类。

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。**

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-nN78auWW-1715737265446)]

[外链图片转存中…(img-PTOZrnNa-1715737265446)]

[外链图片转存中…(img-pABgwci5-1715737265447)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！