AQS源码分析

AQS介绍

AbstractQueuedSynchronizer，AQS是用来构建锁和同步器的框架，Java并发工具包中的可重入所、读写锁都是基于AQS的子类构建的，使用的是组合并发继承，因为对用户（开发者）而言，我们不需要关心底层线程的调度和控制。

     *      +------+  prev +-----+       +-----+
     * head |      | <---- |     | <---- |     |  tail
     *      +------+       +-----+       +-----+
head可看作持有锁的节点

通过CAS的方式对每个任务状态进行变更。

源码分析

首先是AQS的双向队列节点源码：

static final class Node {
        // 独占模式和共享模式：在锁的获取的时候，不一定只有一个线程才能持有这个锁，比如可重入锁解释独占模式，读写锁是共享模式
        static final Node SHARED = new Node();
        static final Node EXCLUSIVE = null;

        // 该节点线程因为超时或者被中断被终止了，应该从队列移除
        static final int CANCELLED =  1;
        // 该节点后面节点被挂起，因此在释放当前节点时，后续节点必须唤醒
        static final int SIGNAL    = -1;
        // 线程等待条件不会被当成同步队列节点，直到被唤醒signal，设置其值为0，重新进入节点阻塞状态
        static final int CONDITION = -2;

        static final int PROPAGATE = -3;

        // 默认值为0，阻塞状态
        volatile int waitStatus;

        volatile Node prev;
        volatile Node next;

        // 当前线程
        volatile Thread thread;

        // 表示共享模式还是独占模式
        Node nextWaiter;
}

独占模式的获取锁操作，我们可以参考可重入锁的NonfairSync实现：

    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }
    public final void acquire(int arg) {
        if (!tryAcquire(arg) && 
            acquireQueued(
            // 向等待队列最后加入一个独占模式的节点，
            addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
    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;
            // cas 操作，防止多线程相互干扰
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        // 设置相关的信息
        enq(node);
        return node;
    }
    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);
        }
    }
    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 {
            // 将前驱结点设为SIGNAL，下次判断前驱节点直接挂起
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

获取锁总结：

1. addWaiter，将node节点加入到同步队列后面
2. acquireQueued，获取该node节点的同步状态，自旋直到node的前驱结点是头结点并且能够获得锁，否则，设置前驱节点为阻塞状态，需要被唤醒才能返回。

释放锁流程：

    public void unlock() {
        sync.release(1);
    }
    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;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

释放锁总结：
释放头结点的锁，若后续节点可被唤醒，则唤醒后续节点，否则从队列后面开始找可唤醒的节点