多线程并发的开端-AQS

---

前言

  多线程并发在java中有着举足轻重的地位。在日常的增删查改项目中可能接触的比较少，可能就线程池接触的多一点，但线程池实现原理中肯定也有AQS的影子。要想理解多线程并发，AQS这个核心类是绕不过的。那么AQS是个什么东西？是如何实现的呢？我们一起来看看。

---

一、AQS是什么？

  它的全称是AbstractQueuedSynchronizer，是juc包下的一个核心类。它提供了用于实现依赖先进先出(FIFO)等待队列的阻塞锁和相关同步器(如信号量，事件等)的一个框架。此类旨在为大多数依赖单个原子{@code int}值表示状态的同步器提供有用的基础。
  子类必须定义更改此状态的受保护方法。tryAcquire、tryAcquireShared、tryRelease、tryReleaseShared、isHeldExclusively等方法需要子类去实现。
并且定义该状态(state)对被获取或释放的对象而言意味着什么。有了这些，该类中的其他方法将执行所有排队和阻塞机制。子类可以维护其他状态字段，但是仅跟踪使用方法自动更新的{@code int}使用方法{@link #getState}，{@ link #setState}和{@link #compareAndSetState}操纵的值同步。

二、源码解析

AQS主要包括以下三部分内容：
  1) 独占模式
  2) 共享模式
  2) 条件对象ConditionObject

1.主要属性

/**
* 等待队列的头节点，懒加载，它的等待状态一定不会为CANCELLED
 */
private transient volatile Node head;

/**
 * 等待队列的尾节点，懒加载
 */
private transient volatile Node tail;

/**
 * 同步状态
 */
private volatile int state;

// cas操作相关
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
private static final long headOffset;
private static final long tailOffset;
private static final long waitStatusOffset;
private static final long nextOffset;

static {
    try {
        stateOffset = unsafe.objectFieldOffset
            (AbstractQueuedSynchronizer.class.getDeclaredField("state"));
        headOffset = unsafe.objectFieldOffset
            (AbstractQueuedSynchronizer.class.getDeclaredField("head"));
        tailOffset = unsafe.objectFieldOffset
            (AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
        waitStatusOffset = unsafe.objectFieldOffset
            (Node.class.getDeclaredField("waitStatus"));
        nextOffset = unsafe.objectFieldOffset
            (Node.class.getDeclaredField("next"));

    } catch (Exception ex) { throw new Error(ex); }
}

Node数据结构：双向链表，封装了线程和等待状态
画个图：

static final class Node {
   /** 节点正在共享模式下等待的标记 */
    static final Node SHARED = new Node();
    /** 节点正在以独占模式等待的标记 */
    static final Node EXCLUSIVE = null;

    /** waitStatus值，表示线程已取消 */
    static final int CANCELLED =  1;
    /** waitStatus值，表示后续线程需要被唤醒 */
    static final int SIGNAL    = -1;
    /** waitStatus值，指示线程正在等待条件 */
    static final int CONDITION = -2;
    /**
     * waitStatus值，指示下一个acquireShared应该无条件传播
     */
    static final int PROPAGATE = -3;
	/** 等待状态，取上面几个值 */
    volatile int waitStatus;

    /**
     * 前节点
     */
    volatile Node prev;

    /**
     * 后节点
     */
    volatile Node next;

    /**
     * 线程
     */
    volatile Thread thread;

    /**
     * 条件队列上的下一个等待节点,共享模式下有特殊值
     */
    Node nextWaiter;

    /**
     * 是否为共享模式，这里就用到了nextWaiter
     */
    final boolean isShared() {
        return nextWaiter == SHARED;
    }

    /**
     * 获取前一个节点
     */
    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }

    Node() {    // Used to establish initial head or SHARED marker
    }

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

2.主要方法

a)独占模式

acquire(int arg)

  在独占模式下获取锁，忽略中断。 通过至少调用一次{@link #tryAcquire}来实现，成功返回。否则，线程将排队，有可能反复阻塞和解除阻塞，调用{@link #tryAcquire}直到成功。此方法可以用于实现方法{@link Lock＃lock}。

public final void acquire(int arg) {
 if (!tryAcquire(arg) && // 先尝试获取锁，该方法交由子类实现
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // 第一次调用tryAcquire失败
        selfInterrupt();
}

/**
* 将当前线程封装成一个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
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {// 因为等待队列是线程共享资源，需要cas去替换尾节点
            pred.next = node;
            return node;
        }
    }
    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;
            }
        }
    }
}

/**
* 如果没获取到锁就阻塞
* 简单说下这个方法逻辑：
* 1、如果该节点前节点为head，则再次尝试获取锁，如果获取失败，则判断是否需要阻塞，如果需要阻塞则进行阻塞。如果获取锁成功，则设置头节点返回，只有这种情况会返回。
* 2、如果该节点前节点不是head,则判断是否需要阻塞，如果需要阻塞则进行阻塞。
*/
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);
    }
}
// 与new Node()保持一致
private void setHead(Node node) {
 	head = node;
    node.thread = null;
    node.prev = null;
}

/**
* 判断是否需要阻塞，如果前一个节点的等待状态为SIGNAL，则表示需要阻塞
* pre:当前线程的前一个节点
* node:当前线程节点
*/
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;// 跳过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;
}

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

最后画个图再整理一下独占模式获取锁的过程：

release(int arg)
  独占模式释放锁。如果{@link #tryRelease}返回true，则解锁一个或多个线程。 此方法可用于实现方法{@link Lock＃unlock}。

/**
* 实现逻辑：尝试释放锁，如果释放成功了则唤醒后继线程，返回true
*/
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) {
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
        
    Node s = node.next;
    if (s == null || s.waitStatus > 0) {// 表示s节点为null或已被取消，则从队尾往前一直找未取消的后继线程
        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);// 找到之后，唤醒s节点的线程
}

acquireInterruptibly(int arg)
  独占模式获取锁，响应中断，如果中断则中止。方法逻辑与acquire方法相同。此方法可以用于实现方法{@link Lock＃lockInterruptible}。源码就不展开讲解了，有兴趣的可以去看看源码。

b)共享模式

acquireShared(int arg)
  在共享模式下获取锁，忽略中断。 通过至少调用一次{@link #tryAcquireShared}来实现，成功返回。否则，线程将排队，有可能反复阻塞和解除阻塞，调用{@link #tryAcquireShared}直到成功。

public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)// 表示获取锁失败
        doAcquireShared(arg);// 添加到等待队列中进行等待
}
// 尝试获取锁，交由子类实现，如果返回小于0则表示获取锁失败
protected int tryAcquireShared(int arg) {
    throw new UnsupportedOperationException();
}
// 该方法与独占模式的逻辑一样，只是拿到锁之后多了传播(唤醒共享模式的后继线程)
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);
    }
}

/**
* propagate表示共享锁的个数，大于0表示后继线程还可以获取共享锁
*/
private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    setHead(node);
    
    if (propagate > 0 || h == null || h.waitStatus < 0 ||
        (h = head) == null || h.waitStatus < 0) {
        Node s = node.next;
        if (s == null || s.isShared())
            doReleaseShared();// 传播
    }
}

/**
* 共享模式下的释放动作，唤醒后继线程
*/
private void doReleaseShared() {
    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;
    }
}

releaseShared(int arg)
  在共享模式下释放锁。

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

共享模式与独占模式对比
  共享模式在当前线程获取到锁时会有条件进行传播，即唤醒共享模式下的线程。其他逻辑基本上一样。

---

c)条件对象ConditionObject

// TODO

总结

  本文介绍了AQS的概念，等待队列的数据结构，独占模式下的获取锁，释放锁的过程，将两个关键方法tryAcquire方法和tryRelease方法交给子类去实现，而ReentrantLock就是通过AQS的独占模式来实现的，阅读完AQS独占模式的源码之后去阅读ReentrantLock源码就比较简单了，大家有兴趣可以去阅读一下。
共享模式和条件对象ConditionObject下期再进行分析。

如理解有误，还望指正！