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队列的形状大概是像下面这个样子
JUC简笔2-AQS源码分析_第1张图片

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的理解停留在代码级别,如有不对和遗漏欢迎各位补充。

你可能感兴趣的:(JUC简笔)