JUC简笔2-AQS源码分析

1、什么是AQS?

AQS全称，AbstractQueuedSynchronizer，意思大概就是“抽象队列同步器”，这个名词有点抽象，我们来先看看源码中的介绍，lalalalala…..，一大段英文。

/**
 * Provides a framework for implementing blocking locks and related
 * synchronizers (semaphores, events, etc) that rely on
 * first-in-first-out (FIFO) wait queues.  This class is designed to
 * be a useful basis for most kinds of synchronizers that rely on a
 * single atomic {@code int} value to represent state. Subclasses
 * must define the protected methods that change this state, and which
 * define what that state means in terms of this object being acquired
 * or released.  Given these, the other methods in this class carry
 * out all queuing and blocking mechanics. Subclasses can maintain
 * other state fields, but only the atomically updated {@code int}
 * value manipulated using methods {@link #getState}, {@link
 * #setState} and {@link #compareAndSetState} is tracked with respect
 * to synchronization.
 * */

翻译过来大概就是：
1、AQS是一个用于实现阻塞锁和相关同步器 (semaphores, events等等)的框架，它是基于FIFO等待队列的；
2、AQS是“以单个原子值(int)表示状态的同步器”为基础的；
3、子类必须定义protected的方法来改变状态，还必须根据这个对象被acquired或released来定义状态的含义，且只能通过getState()、setState()、compareAndSetState()来更新状态值。

2、AQS的组成

这里没也什么好说的，与其说一大堆不如直接上源码看组成

public abstract class AbstractQueuedSynchronizer 
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
    private static final long serialVersionUID = 7373984972572414691L;
    //构造方法
    protected AbstractQueuedSynchronizer() { }
    //定义了一个静态内部类Node
    //AQS内部维护了一个CLH队列，Node是这个队列的节点
    static final class Node {...}
    //队列头指针
    private transient volatile Node head;
    //队列尾指针
    private transient volatile Node tail;
    //状态位
    private volatile int state;

    //获取状态位state
    protected final int getState() {
        return state;
    }

    //设置状态位state
    protected final void setState(int newState) {
        state = newState;
    }

    //通过CAS设置位state
    protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

    //一大堆方法.....
}

3、AQS中的CLH队列

关于CLH队列，有个很有趣的地方，我以为CLH是三个英文单词的缩写，但说明里是这样写的——”CLH” (Craig, Landin, and Hagersten)，应该是三个大佬的名字。
源码中的说明翻译过来就是： AQS中的等待队列是CLH阻塞队列的变种，CLH的锁常用于自旋锁。相反，我们使用它们来阻塞同步器，但使用相同的基本策略来hold住前节点(prev)的控制信息。每个节点中的“状态”字段跟踪线程是否应该被阻塞。

对于这里，我的理解是AQS中的CLH队列并没有使用自旋锁，而是用状态值来判断线程是否应该被阻塞。（如果理解错了希望广大网友可以纠正）

下面我们来分析CLH的节点类：

static final class Node {
            /*
            AQS定义两种资源共享方式：Exclusive（独占，只有一个线程能执行，如ReentrantLock）和
            Share（共享，多个线程可同时执行，如Semaphore/CountDownLatch）
            */
            /** 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;

            /**
             * Status field, taking on only the values:
             *   SIGNAL:     当前线程的后继线程需要被unpark(唤醒)”，对应的Status值
             *                当前线程的后继线程处于阻塞状态，而当前线程被release或cancel掉，
             *                因此需要唤醒当前线程的后继线程。
             *   
             *   CANCELLED:  结点被由于超时或中断被撤销，且再也无法离开这个状态；
             *   
             *   CONDITION:  结点在条件队列中，因为等待某个条件而被阻塞；它将不被用作同步队列节
             *                点，直到状态值改变为0;
             * 
             *              
             *   PROPAGATE:  大概意思是这是保证下一次可以直接传播的状态
             *   0:          除以上状态外的状态
             *
             *
             * 结点初始化时，waitStatus位为0, 要使用CAS进行修改。
             */
             volatile int waitStatus;
             //前指针 
             volatile Node prev;
             //后指针
             volatile Node next;
             //进入队列的线程
             volatile Thread thread;
             //条件队列中的下一个结点
             Node nextWaiter;

             /**
             *下面是方法
             *返回结点是否是share模式
             */
            final boolean isShared() {
                return nextWaiter == SHARED;
            }

            /**
             * 返回该结点的前结点, 如果前结点为空，则抛出空指针异常
             */
            final Node predecessor() throws NullPointerException {
                Node p = prev;
                if (p == null)
                    throw new NullPointerException();
                else
                    return p;
            }

            //空参构造方法
            Node() {   
            }

            Node(Thread thread, Node mode) {     // Used by addWaiter
                this.nextWaiter = mode;
                this.thread = thread;
            }

            Node(Thread thread, int waitStatus) { // Used by Condition
                this.waitStatus = waitStatus;
                this.thread = thread;
            }
    }

}

由源码可知，CLH队列的形状大概是像下面这个样子

4、AQS的主要方法分析

1) acquire() 获取锁

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

方法流程：
1. tryAcquire（）：尝试获取锁；
2. addWaiter(Node.EXCLUSIVE)：获取锁失败，将该线程加入CLH列尾部，且标记为独占模式；
3. acquireQueued（Node，int）：当前线程会根据公平性原则来进行阻塞等待,直到获取锁为止；

2) tryAcquire() 尝试获取锁

protected boolean tryAcquire(int arg) {  
        throw new UnsupportedOperationException();  
    }  

该方法并没有具体实现，需要子类重写，在该类中只是抛出了一个异常。

3) addWaiter()

private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;
        if (pred != null) {
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);//从尾部插入CLH队列
        return node;
}

作用：会首先创建一个Node节点，然后再将该节点添加到CLH队列的末尾。
该方法结构较简单，核心为enq(node); 接下来分析enq()方法;

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

作用：将当前线程添加到CLH队列中
方法流程：
1. 如果tail为空，说明CLH为空，初始化CLH，创建一个空节点为CLH的head，当前结点为CLH的tail
2. 设当前节点的前任节点为之前的tail，再设当前节点为尾节点；
3. 不断循环，直到设置成功；

4) acquireQueued()

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

    }

方法用途原文为Acquires in exclusive uninterruptible mode for thread already in queue.，不太好理解；
直接翻译过来就是“为已经在等待队列中且处于不可中断的独占模式下的线程获取锁”；

作用：从CLH队列中获取锁
方法流程：
1. node.predecessor()：获取当前结点的前结点；
2. 获取成功后设置当前结点为头结点，获取锁，如果成功获取锁，回收原来的头结点，返回false；否则执行3；
3. shouldParkAfterFailedAcquire() ：如果前结点被阻塞（waitState为SINGAL）则返回true，如果前结点被取消（waitState为CANCEL）则跳过前节点，设前前结点的后继为当前结点；
4. parkAndCheckInterrupt()：阻塞并判断是否被中断，被中断则返回true；
5. 继续循环，直到获取锁

5) shouldParkAfterFailedAcquire()

// 
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        return true;

    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 如果前继节点为“0”或者“共享锁”状态，则设置前继节点为SIGNAL状态。
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

作用： 返回“当前线程是否应该阻塞”
方法流程：
1.获取前继节点的状态；
2. 如果前继节点是SIGNAL状态，则意味这当前线程需要被unpark唤醒。此时，返回true；
3. 如果前继节点是“取消”状态，则设置 “当前节点”的 “当前前继节点” 为 “‘原前继节点’的前继节点”（跳过状态为CANCEL的结点）；

6) release() 、tryRelease()

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

protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }

两个方法较简单，不作分析，下面直接分析unparkSuccessor()；

7) unparkSuccessor()

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

作用： 唤醒后继结点
方法流程：
1. 如果当前节点的状态小于0，则设它的waitStatus为0；
2. 获得当前节点的后节点，如果为空或者被在被撤销状态，则从CLH的尾部开始，找到一个不为空且waitStatus小于0的结点。
3. 唤醒满足条件的节点；

AQS的源码分析就到这里为止，由于本人目前功力尚浅，很多地方只能翻译原文来理解，对AQS的理解停留在代码级别，如有不对和遗漏欢迎各位补充。