深入理解AQS队列同步器原理-从ReentrantLock的非公平独占锁实现来看AQS的原理

final boolean initialTryLock() {
// 获取当前线程
            Thread current = Thread.currentThread();
            // AQS的方法
            if (compareAndSetState(0, 1)) { // first attempt is unguarded
            
                setExclusiveOwnerThread(current);
                return true;
            } else if (getExclusiveOwnerThread() == current) {
            // AQS的方法
                int c = getState() + 1;
                if (c < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                    // AQS的方法
                setState(c);
                return true;
            } else
                return false;
        }

final void lock() {
			// 加锁失败设置执行acquire
			// jdk17在此处优化，旧版本直接set，可重入在其他地方实现
			// 这里获得锁就会执行lock()后面的函数
            if (!initialTryLock())
                acquire(1);
        }


final boolean initialTryLock() {
            Thread current = Thread.currentThread();
            // 尝试获取锁，获取到了用父类方法将当前线程设置为获得锁的线程
            // 0无锁 1加锁
            if (compareAndSetState(0, 1)) { // first attempt is unguarded
                setExclusiveOwnerThread(current);
                return true;
                // 如果就是当前线程获得锁了，那么就state+1，说明AQS是可重入锁
            } else if (getExclusiveOwnerThread() == current) {
                int c = getState() + 1;
                // 小于0，抛出异常，重入次数超过int最大值会抛出
                if (c < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(c);
                return true;
            } else
                return false;
        }
public final void acquire(int arg) {
		// 这里直接抛出异常 取非执行acqurie
        if (!tryAcquire(arg))
        // 参数：node节点 是否共享 是否中断 两个时间相关的
            acquire(null, arg, false, false, false, 0L);
    }

// AQS除了标识加锁无锁之外还应该提供其他状态 这里留给子类实现，
// ReentrantLock没有实现而已,不用抽象类是因为不是所有的子类都要实现
// 见后文思考
protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

final int acquire(Node node, int arg, boolean shared,
                      boolean interruptible, boolean timed, long time) {
        // 获取当前线程
        Thread current = Thread.currentThread();
        byte spins = 0, postSpins = 0;   // retries upon unpark of first thread
        boolean interrupted = false, first = false;
        Node pred = null;                // predecessor of node when enqueued

        for (;;) {
        // 如果是头节点返回head，否则返回null
        // 如果不是头节点，node.pred是当前节点的前驱节点
        // 也就是JDK源码敢这么写吧，可读性真的...
            if (!first && (pred = (node == null) ? null : node.prev) != null &&
                !(first = (head == pred))) {
                // 重入过多，小于0，清楚队列，cleanQueeu纯纯算法
                if (pred.status < 0) {
                    cleanQueue();           // predecessor cancelled
                    continue;
                } else if (pred.prev == null) {
                // 前前节点是空，onSpinWait是Thread的空方法
                    Thread.onSpinWait();    // ensure serialization
                    continue;
                }
            }
            if (first || pred == null) {
            // 这里才是理想情况应该进来的
                boolean acquired;
                try {
                    if (shared)
                    // 共享锁执行，tryAcquireShared同样是子类实现
                        acquired = (tryAcquireShared(arg) >= 0);
                    else
                    // 非共享锁执行
                        acquired = tryAcquire(arg);
                } catch (Throwable ex) {
                // 取消尝试获取锁
                    cancelAcquire(node, interrupted, false);
                    throw ex;
                }
                if (acquired) {
                    if (first) {
                        node.prev = null;
                        head = node;
                        pred.next = null;
                        node.waiter = null;
                        if (shared)
                            signalNextIfShared(node);
                        if (interrupted)
                            current.interrupt();
                    }
                    return 1;
                }
            }
            if (node == null) {
            // 这里做了共享锁和排他锁的不同实现，只是一个标识而已
            // 他们都是继承了Node，没有添加任何东西
                if (shared)
                    node = new SharedNode();
                else
                    node = new ExclusiveNode();
            } else if (pred == null) {          // try to enqueue
                node.waiter = current;
                Node t = tail;
                node.setPrevRelaxed(t);         // avoid unnecessary fence
                if (t == null)
                    tryInitializeHead();
                else if (!casTail(t, node))
                // Node提供的一系列原子操作
                    node.setPrevRelaxed(null);  // back out
                else
                    t.next = node;
            } else if (first && spins != 0) {
                --spins;                        // reduce unfairness on rewaits
                Thread.onSpinWait();
            } else if (node.status == 0) {
                node.status = WAITING;          // enable signal and recheck
            } else {
                long nanos;
                spins = postSpins = (byte)((postSpins << 1) | 1);
                if (!timed)
                // 这里用到了前置知识，给了一个许可
                    LockSupport.park(this);
                else if ((nanos = time - System.nanoTime()) > 0L)
                    LockSupport.parkNanos(this, nanos);
                else
                    break;
                node.clearStatus();
                if ((interrupted |= Thread.interrupted()) && interruptible)
                    break;
            }
        }
        // 取消尝试获取锁
        return cancelAcquire(node, interrupted, interruptible);
    }