java AQS源码分析

java常用的锁ReentrantLock主要利用AQS框架实现，ReentrantLock主要结构如图

其主要利用的是内部类Sync来实现加锁解锁操作，而Sync继承了AbstractQueuedSynchronizer累，大部分操作由AbstractQueuedSynchronizer来完成

ReentrantLock常用方法为加锁lock()与解锁unlock(), 加锁利用了AbstractQueuedSynchronizer的acquire方法，AbstractQueuedSynchronizer本身没有实现tryAcquire方法，并且抛出一个异常强制子类必须实现才能成为一个锁类，ReentrantLock通过内部类NonfairSync与FairSync提供了两个不同的tryAcquire实现来构造公平锁或者与公平锁，下面先介绍公平锁的原理

protected boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            } else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

public final void acquire(int arg) {
        if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

该方法先调用tryAcquire来快速尝试获取锁，若失败则先调用addWaiter方法来构造一个同步节点，通过死循环+cas方式将此节点加到同步队列尾部，然后调用 acquireQueued来循环获取同步状态，获取到了才推出，因为只要当前节点是头节点时才能拿到状态，所以该过程类似于接力棒，从头结点开始往后一个个获取到同步状态

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

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

获取同步状态的节点释放是调用release方法，由此实现了加锁解锁操作，并且按照线程请求顺序依次进行

public final boolean release(int arg) {
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);//该节点释放同步状态，并唤醒下一个节点
            return true;
        }
        return false;
    }