概述

AbstractQueuedSynchronizer，简称 AQS，它提供了同步器框架的形象实现，ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier 等并发类均是基于 AQS 来实现的，具体用法是通过继承 AQS 实现其模板办法，而后将子类作为同步组件的外部类。

源码剖析

成员变量

head 和 tail 节点

这俩个节点是 Node 类型的，前面会说先看代码

    // 期待队列的头节点，惰性初始化。除了初始化外只能被 setHead 办法批改，并且节点的 waitStatus 不能为 CANCELLED
    private transient volatile Node head;
    // 期待队列的尾节点，惰性初始化，只会在调用 enq 办法增加期待节点时批改
    private transient volatile Node tail;

state

AQS 维持了一个繁多的 volatile 的 state 变量，并通过 unsafe 办法来原子性的获取和设置该值

/**
     * The synchronization state.
     */
    private volatile int state;

    protected final int getState() {return state;}

    protected final void setState(int newState) {state = newState;}
    
    protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

spinForTimeoutThreshold

static final long spinForTimeoutThreshold = 1000L;

实现办法

 private Node enq(final Node node) {for (;;) {
            Node t = tail;
            // 第一次入队，head 和 tail 都为 null
            if (t == null) { // Must initialize
                // 原子设置头节点
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                // 原子设置尾节点
                if (compareAndSetTail(t, node)) {
                    t.next = node;
                    return t;
                }
            }
        }
    }

应用传入的 mode 节点来让以后线程入队

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