protected final boolean tryAcquire(int acquires) {
            //首先得到获取锁的当前线程
            final Thread current = Thread.currentThread();
            //获取当前state
            int c = getState();
            //如果当前没有线程获取锁
            if (c == 0) {
                //hasQueuedPredecessors表示当前队列是否有线程在等待
                //表示没有线程在等待，同时采用CAS更新state的状态
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    //然后设置一个属性exclusiveOwnerThread = current，记录锁被当前线程拿去
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            //如果c != 0，说明已经有线程获取锁，并且getExclusiveOwnerThread == current,表示当前正在获取锁的就是当前锁，所以这里是重入！
            else if (current == getExclusiveOwnerThread()) {
                //重入的话，让状态为state+1，表示多一次重入
                int nextc = c + acquires;
                //如果当前状态<0，说明出现异常
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                //设置当前标志位
                setState(nextc);
                return true;
            }
            //如果锁已经被获取，并且又不是重入，所以返回false，表明获取锁失败
            return false;
        }
    }

private Node addWaiter(Node mode) {
        //把当前线程按照Node.EXECLUSIVE模式包装成1个Node
        Node node = new Node(Thread.currentThread(), mode);
        //用pred表示队列中的尾节点
        Node pred = tail;
        //如果尾节点不为空
        if (pred != null) {
            node.prev = pred;
            //通过CAS操作把node插入到列表的尾部，并把尾节点指向node如果失败，说明有并发，此时调用enq
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        //如果队列为空，或者CAS失败，进入enq中死循环，“自旋”方式修改。
        enq(node);
        return node;
    } 

 private Node enq(final Node node) {
        //进入死循环
        for (;;) {
            Node t = tail;
            //如果尾节点为null，说明队列为空
            if (t == null) {
                //此时通过CAS增加一个头结点(即上图的黄色节点)，并且tail也指向头结点，之后下一次循环
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {//否则，把当前线程的node插入到尾节点的后面
                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();
                //如果当前的节点是head说明他是队列中第一个“有效的”节点，因此尝试获取，
                if (p == head && tryAcquire(arg)) {
                //成功后，将上图中的黄色节点移除，Node1变成头节点。
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    //返回true表示已经插入到队列中，且已经做好了挂起的准备
                    return interrupted;
                }
                //否则，检查前一个节点的状态为，看当前获取锁失败的线程是否需要挂起。如果需要，借助JUC包下的LockSopport类的静态方法Park挂起当前线程。知道被唤醒。
                if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) 
                    interrupted = true;
            }
        } finally {
            if (failed) //如果有异常
                cancelAcquire(node);// 取消请求，对应到队列操作，就是将当前节点从队列中移除。
        }
    } 

final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            //如果当前没有现成获取锁，直接获取锁，然后设置一个属性exclusiveOwnerThread = current，记录锁被当前线程拿去，这里和公平所有细微的差别，公平所还要判断hasQueuedPredecessors（）
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }//如果是重入
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            //如果当前锁获取失败，返回false
            return false;
        }

  protected final boolean tryRelease(int releases) {
            //这里传入的releases是1，跟获取锁时传入的1一致，更新state状态
            int c = getState() - releases;
            //如果当前占领锁的线程不是尝试释放锁的线程，会抛出非法异常
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            //如果释放成功，则修改获取锁的变量为null，但是因为是重入的关系，不是每次释放锁c都等于0，直到最后一次释放锁时，才通知AQS不需要再记录哪个线程正在获取锁
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }