CAS和ASQ原理（源码详解）

前面介绍Java中的锁机制时简单介绍过CAS和ASQ，这篇文章则是进行详细的学习介绍。

一、CAS（CompareAndSwamp，比较并交换）

1、简介
CAS有3个操作数：
内存值V、预期值A、更新值B
只有当V=A时，才把V更新为B。
过程简介：
　　更新时，判断只有A的值等于V变量的当前旧值时，才会将B新值赋给V，更新为新值。
　　否则，则认为已经有其他线程更新过了，则当前线程什么都不操作，最后cas放回当前V变量的真实值。
　　
2、代码分析
附上AromicInteger中原子操作的源码：

public class AtomicInteger extends Number implements java.io.Serializable {
	private static final Unsafe unsafe = Unsafe.getUnsafe();
	
	private static final long valueOffset;

	
    /**
     * Atomically increments by one the current value.
     *
     * @return the previous value
     */
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }
	
	/**
	 * Atomically increments by one the current value.
	 *
	 * @return the updated value
	 */
	public final int incrementAndGet() {
	    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
	}

	private volatile int value;
	
    /**
     * Creates a new AtomicInteger with the given initial value.
     *
     * @param initialValue the initial value
     */
    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
	
    /**
     * Gets the current value.
     *
     * @return the current value
     */
    public final int get() {
        return value;
    }

	
    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }
	
    /**
     * Atomically updates the current value with the results of
     * applying the given function to the current and given values,
     * returning the updated value. The function should be
     * side-effect-free, since it may be re-applied when attempted
     * updates fail due to contention among threads.  The function
     * is applied with the current value as its first argument,
     * and the given update as the second argument.
     *
     * @param x the update value
     * @param accumulatorFunction a side-effect-free function of two arguments
     * @return the updated value
     * @since 1.8
     */
    public final int accumulateAndGet(int x,
                                      IntBinaryOperator accumulatorFunction) {
        int prev, next;
        do {
            prev = get();
            next = accumulatorFunction.applyAsInt(prev, x);
        } while (!compareAndSet(prev, next));
        return next;
    }
}

public final class Unsafe {
	private static final Unsafe theUnsafe;

	@CallerSensitive
    public static Unsafe getUnsafe() {
        Class var0 = Reflection.getCallerClass();
        if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
            throw new SecurityException("Unsafe");
        } else {
            return theUnsafe;
        }
    }

	public native int getIntVolatile(Object var1, long var2);

	public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

	public final int getAndAddInt(Object var1, long var2, int var4) {
        int var5;
        do {
        	// 获取var1 对象 var2这个地址的值
            var5 = this.getIntVolatile(var1, var2);
            // 如果var1 对象的var2地址的值和var5 一样，那么执行var5=var5+var4
        } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
		//返回的var5 是取出的那个值，而不是 var5+var4 的值
        return var5;
    }
}

getAndIncrement()返回的是原值，表示的是i++;
incrementAndGet()返回的是原值+1，表示的是++i。
根据方法名就能看出区别，get在前就是先获取i值在执行+1操作，get在后就是先执行+1操作，然后再获取i值。（注意：原子类中很多方法都可根据这种方式判断原理。）

accumulateAndGet()方法（对应的有getAndAccumulate()方法区别同上）相关介绍可查看如下地址：
https://vimsky.com/examples/usage/atomicinteger-accumulateandget-method-in-java-with-examples.html

注意：
　　当大量线程访问相同的原子值，性能会大幅下降，所以Java8提供了LongAdder和LongAccumulator来解决该问题。

二、AQS（AbstractQueuedSynchronizer, 队列同步器）

1、简介
　　AQS是Java并发用来构建锁和其他同步组件的基础框架。AQS是一个抽象类（AbstractQueuedSynchronizer），主是是以继承的方式使用。AQS本身是没有实现任何同步接口的，它仅仅只是定义了同步状态的获取和释放的方法来供自定义的同步组件的使用。一般是同步组件的静态内部类，即通过组合的方式使用。
　　抽象的队列式的同步器，AQS定义了一套多线程访问共享资源的同步器框架，许多同步类实现都依赖于它，如常用的ReentrantLock/Semaphore/CountDownLatch。
（1）原理简介
　　维护了一个volatile int state（代表共享资源）和一个FIFO（双向队列）线程等待队列（多线程争用资源被阻塞时会进入此队列）。
（2）共享变量state
state的访问方式有三种:getState()、setState()、compareAndSetState()。
　　同步状态（可理解为锁）就是这个int型的变量state。head和tail分别是同步队列的头结点和尾结点。假设state=0表示同步状态可用（如果用于锁，则表示锁可用），state=1表示同步状态已被占用（锁被占用）。
（3）FIFO线程阻塞队列

state=0表示锁是空闲状态，state=1表示琐是被占用状态。
head指向占用锁线程所在的结点，后续线程会依次存放在后面的结点tail指向最后的结点，从head出，tail进入。

下面开始进行AQS工作机制的具体解析：
参考自知乎上的一篇文章，解析简单易懂（https://zhuanlan.zhihu.com/p/141715040）

2、举例说明AQS获取和释放的大致过程
（1）获取同步状态
　　假设线程A要获取同步状态（这里想象成锁，方便理解），初始状态下state=0,所以线程A可以顺利获取锁，A获取锁后将state置为1。在A没有释放锁期间，线程B也来获取锁，此时因为state=1，表示锁被占用，所以将B的线程信息和等待状态等信息构成出一个Node节点对象，放入同步队列，head和tail分别指向队列的头部和尾部（此时队列中有一个空的Node节点作为头点，head指向这个空节点，空Node的后继节点是B对应的Node节点，tail指向它），同时阻塞线程B(这里的阻塞使用的是LockSupport.park()方法)。
　　后续如果再有线程要获取锁，都会加入队列尾部并阻塞。
（2）释放同步状态
　　当线程A释放锁时，即将state置为0，此时A会唤醒头节点的后继节点（所谓唤醒，其实是调用LockSupport.unpark(B)方法），即B线程从LockSupport.park()方法返回，此时B发现state已经为0，所以B线程可以顺利获取锁，B获取锁后B的Node节点随之出队。

3、代码分析
　　若要分析AQS的源码，咱们还是绕不开ReentrantLock，的源码确实值得精读、细品，接下来就AQS进行相关的源码分析。

public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    /** Synchronizer providing all implementation mechanics */
    private final Sync sync;

    /**
     * Base of synchronization control for this lock. Subclassed
     * into fair and nonfair versions below. Uses AQS state to
     * represent the number of holds on the lock.
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {}

    /**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {}

    /**
     * Sync object for fair locks
     */
    static final class FairSync extends Sync {}
}

Sync是一个继承抽象类AbstractQueuedSynchronizer（队列同步器-AQS）的抽象类，他有两个实现类FairSync和NonfairSync，分别对应的是公平锁和非公平锁。

/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

ReentrantLock提供了上面的有参构造函数通过一个入参为boolean来确认获取的是公平锁还是非公平锁。

/**
 * Creates an instance of {@code ReentrantLock}.
 * This is equivalent to using {@code ReentrantLock(false)}.
 */
public ReentrantLock() {
    sync = new NonfairSync();
}

上面这个无参构造函数，获取的是NonfairSync（非公平锁），其实就是一个ReentrantLock实例。

下面以NonFairSync为例：
1.获取锁

   /**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

（1）lock()方法
　　先通过CAS尝试将同步状态(AQS的state属性)从0修改为1。若直接修改成功了，则将占用锁的线程设置为当前线程。
　　
1）compareAndSetState()
　　如果当前状态值等于预期值，则自动将同步状态设置为给定的更新值。这个操作具有volatile读和写的内存语义。

/**
 * Atomically sets synchronization state to the given updated
 * value if the current state value equals the expected value.
 * This operation has memory semantics of a {@code volatile} read
 * and write.
 *
 * @param expect the expected value
 * @param update the new value
 * @return {@code true} if successful. False return indicates that the actual
 *         value was not equal to the expected value.
 */
protected final boolean compareAndSetState(int expect, int update) {
    // See below for intrinsics setup to support this
    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

compareAndSetState底层其实是调用的unsafe的CAS系列方法。
2）setExclusiveOwnerThread()
　　设置当前拥有独占访问权的线程。null参数表示没有线程拥有访问权限。此方法不会强制执行任何同步或volatile字段访问。

/**
 * A synchronizer that may be exclusively owned by a thread.  This
 * class provides a basis for creating locks and related synchronizers
 * that may entail a notion of ownership.  The
 * {@code AbstractOwnableSynchronizer} class itself does not manage or
 * use this information. However, subclasses and tools may use
 * appropriately maintained values to help control and monitor access
 * and provide diagnostics.
 *
 * @since 1.6
 * @author Doug Lea
 */
public abstract class AbstractOwnableSynchronizer implements java.io.Serializable {
    /**
     * The current owner of exclusive mode synchronization.
     */
    private transient Thread exclusiveOwnerThread;

	/**
	 * Sets the thread that currently owns exclusive access.
	 * A {@code null} argument indicates that no thread owns access.
	 * This method does not otherwise impose any synchronization or
	 * {@code volatile} field accesses.
	 * @param thread the owner thread
	 */
	protected final void setExclusiveOwnerThread(Thread thread) {
	    exclusiveOwnerThread = thread;
	}
}

setExclusiveOwnerThread()方法和exclusiveOwnerThread属性是AQS从父类AbstractOwnableSynchronizer中继承的属性，用来保存当前占用同步状态的线程。
3）acquire()
　　如果CAS操作未能成功，说明state已经不为0，此时继续acquire(1)操作，这个acquire()由AQS实现提供：

	/**
	* Acquires in exclusive mode, ignoring interrupts.  Implemented
	* by invoking at least once {@link #tryAcquire},
	* returning on success.  Otherwise the thread is queued, possibly
	* repeatedly blocking and unblocking, invoking {@link
	* #tryAcquire} until success.  This method can be used
	* to implement method {@link Lock#lock}.
	*
	* @param arg the acquire argument.  This value is conveyed to
	*        {@link #tryAcquire} but is otherwise uninterpreted and
	*        can represent anything you like.
	*/
	public final void acquire(int arg) {
	    if (!tryAcquire(arg) &&
	        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
	        selfInterrupt();
	}

在独占模式下获取，忽略中断。通过至少调用一次tryAcquire来实现，成功时返回。否则，线程将进入队列，可能会重复阻塞和解除阻塞，调用tryAcquire直到成功。这个方法可以用来实现Lock.lock方法。

tryAcquire返回false,接着执行addWaiter(Node.EXCLUSIVE)，这个方法创建结点并入队列。

/**
* Tail of the wait queue, lazily initialized.  Modified only via
* method enq to add new wait node.
*/
private transient volatile Node tail;

/**
 * Creates and enqueues node for current thread and given mode.
 *
 * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
 * @return the new node
 */
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);
    return node;
}

首先创建一个Node对象，Node中包含了当前线程和Node模式(这时是排他模式)。tail（tail指的是等待队列的尾部，惰性初始化。仅通过方法enq修改以添加新的等待节点。）是AQS的中表示同步队列队尾的属性，刚开始为null，所以进行enq(node)方法，从字面可以看出这是一个入队操作。

/**
 * Inserts node into queue, initializing if necessary. See picture above.
 * @param node the node to insert
 * @return node's predecessor
 */
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;
            }
        }
    }
}

方法体是一个死循环，本身没有锁，可以多个线程并发访问，假如某个线程进入方法，此时head, tail都为null, 进入if(t==null)区域，从方法名可以看出这里是用CAS的方式创建一个空的Node作为头结点，因为此时队列中只一个头结点，所以tail也指向它，第一次循环执行结束。注意这里使用CAS（compareAndSetHead()方法）是防止多个线程并发执行到这儿时，只有一个线程能够执行成功，防止创建多个同步队列。
　　进行第二次循环时(或者是其他线程enq时)，tail不为null，进入else区域。将当前线程的Node结点(简称CNode)的prev指向tail，然后使用CAS将tail指向CNode。

/**
 * CAS head field. Used only by enq.
 */
private final boolean compareAndSetHead(Node update) {
    return unsafe.compareAndSwapObject(this, headOffset, null, update);
}

/**
 * CAS tail field. Used only by enq.
 */
private final boolean compareAndSetTail(Node expect, Node update) {
    return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}

expect为t, t此时指向tail,所以可以CAS成功，将tail重新指向CNode。此时t为更新前的tail的值，即指向空的头结点，t.next=node，就将头结点的后续结点指向CNode，返回头结点。其他线程再插入节点以此类推，都是在追加到链表尾部，并且通过CAS操作保证线程安全。通过上面分析可知，AQS的写入是一种双向链表的插入操作，至此addWaiter分析完毕。
　　
addWaiter返回了插入的节点，作为acquireQueued方法的入参。

/**
 * Acquires in exclusive uninterruptible mode for thread already in
 * queue. Used by condition wait methods as well as acquire.
 *
 * @param node the node
 * @param arg the acquire argument
 * @return {@code true} if interrupted while waiting
 */
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);
    }
}

可以看到，acquireQueued方法也是一个死循环，直到进入 if (p == head && tryAcquire(arg))条件方法块。还是接着刚才的操作来分析。acquireQueued接收的参数是addWaiter方法的返回值，也就是刚才的CNode节点，arg=1。　　　　　　node.predecessor()返回CNode的前置节点，在这里也就是head节点，所以p==head成立，进而进行tryAcquire操作，即争用锁, 如果获取成功，则进入if方　　法体，看下接下来的操作：

1. 将CNode设置为头节点。
2. 将CNode的前置节点设置的next设置为null。
   上面操作即完成了FIFO的出队操作。

从上面的分析可以看出，只有队列的第二个节点可以有机会争用锁，如果成功获取锁，则此节点晋升为头节点。对于第三个及以后的节点，if (p == head)条件不成立，首先进行shouldParkAfterFailedAcquire(p, node)操作（争用锁失败的第二个节点也如此）。

/**
 * Checks and updates status for a node that failed to acquire.
 * Returns true if thread should block. This is the main signal
 * control in all acquire loops.  Requires that pred == node.prev.
 *
 * @param pred node's predecessor holding status
 * @param node the node
 * @return {@code true} if thread should block
 */
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.
         */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

shouldParkAfterFailedAcquire方法是判断一个争用锁的线程是否应该被阻塞。它首先判断一个节点的前置节点的状态是否为Node.SIGNAL，如果是，是说明此节点已经将状态设置如果锁释放，则应当通知它，所以它可以安全的阻塞了，返回true。
　　如果前节点的状态大于0，即为CANCELLED状态时，则会从前节点开始逐步循环找到一个没有被“CANCELLED”节点设置为当前节点的前节点，返回false。在下次循环执行shouldParkAfterFailedAcquire时，返回true。这个操作实际是把队列中CANCELLED的节点剔除掉。
　　前节点状态小于0的情况是对应ReentrantLock的Condition条件等待的，这里不进行展开。
　　如果shouldParkAfterFailedAcquire返回了true，则会执行：parkAndCheckInterrupt()方法，它是通过LockSupport.park(this)将当前线程挂起到WATING状态，它需要等待一个中断、unpark方法来唤醒它，通过这样一种FIFO的机制的等待，来实现了Lock的操作。
（2）tryAcquire()方法

public class ReentrantLock implements Lock, java.io.Serializable {
        /**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
         */
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            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;
        }
}

首先获取AQS的同步状态(state)，在锁中就是锁的状态，如果状态为0，则尝试设置状态为arg(这里为1), 若设置成功则表示当前线程获取锁，返回true。这个操作外部方法lock()就做过一次，这里再做只是为了再尝试一次，尽量以最简单的方式获取锁。
　　如果状态不为0，再判断当前线程是否是锁的owner(即当前线程在之前已经获取锁，这里又来获取)，如果是owner, 则尝试将状态值增加acquires，如果这个状态值越界，抛出异常；如果没有越界，则设置后返回true。这里可以看非公平锁的涵义，即获取锁并不会严格根据争用锁的先后顺序决定。这里的实现逻辑类似synchroized关键字的偏向锁的做法，即可重入而不用进一步进行锁的竞争，也解释了ReentrantLock中Reentrant的意义。
　　如果状态不为0，且当前线程不是owner，则返回false。

2.释放锁
ReentrantLock中的unLock方法：

/**
 * Attempts to release this lock.
 *
 * <p>If the current thread is the holder of this lock then the hold
 * count is decremented.  If the hold count is now zero then the lock
 * is released.  If the current thread is not the holder of this
 * lock then {@link IllegalMonitorStateException} is thrown.
 *
 * @throws IllegalMonitorStateException if the current thread does not
 *         hold this lock
 */
public void unlock() {
    sync.release(1);
}

AbstractQueuedSynchronizer（AQS）中的release方法：

/**
 * Releases in exclusive mode.  Implemented by unblocking one or
 * more threads if {@link #tryRelease} returns true.
 * This method can be used to implement method {@link Lock#unlock}.
 *
 * @param arg the release argument.  This value is conveyed to
 *        {@link #tryRelease} but is otherwise uninterpreted and
 *        can represent anything you like.
 * @return the value returned from {@link #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;
}

unlock调用AQS的release()来完成, AQS的tryRelease方法由具体子类实现。tryRelease返回true,则会将head传入到unparkSuccessor(Node)方法中并返回true，否则返回false。
ReentrantLock中Sync中的tryRelease方法实现：

protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
}

这个动作可以认为就是一个设置锁状态的操作，而且是将状态减掉传入的参数值（参数是1），如果结果状态为0，就将排它锁的Owner设置为null，以使得其它的线程有机会进行执行。
　　在排它锁中，加锁的时候状态会增加1（当然可以自己修改这个值），在解锁的时候减掉1，同一个锁，在可以重入后，可能会被叠加为2、3、4这些值，只有unlock()的次数与lock()的次数对应才会将Owner线程设置为空，而且也只有这种情况下才会返回true。

在方法unparkSuccessor(Node)中，就意味着真正要释放锁了，它传入的是head节点（head节点是占用锁的节点）。

/**
 * Wakes up node's successor, if one exists.
 *
 * @param node the node
 */
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);
}

首先会发生的动作是获取head节点的next节点，如果获取到的节点不为空，则直接通过：LockSupport.unpark()方法来释放对应的被挂起的线程，这样一来将会有一个节点唤醒后继续进入循环进一步尝试tryAcquire()方法来获取锁。