private volatile int state; // 共享变量，使用volatile修饰保证线程可见性

public final void acquire(int arg) {  
 // 先看尝试获取同步状态看是否成功，如果成功则方法结束返回  
 // 若失败则先调用addWaiter()方法加入到等待队列尾
 // 再调用acquireQueued()方法在队列中等待重试竞争锁或休眠
 if (!tryAcquire(arg) &&  
 acquireQueued(addWaiter(Node.EXCLUSIVE), arg))  
 selfInterrupt();  
}

private Node addWaiter(Node mode) {  
    // 1.将当前线程构建成Node类型  
    Node node = new Node(Thread.currentThread(), mode);  
    // Try the fast path of enq; backup to full enq on failure  
    // 2.尾节点是否为null？  
    Node pred = tail;  
    if (pred != null) {  
        // 2.2 将当前节点以尾插的方式插入同步队列中  
        node.prev = pred;  
        if (compareAndSetTail(pred, node)) {  
             pred.next = node;
             return node;
        }  
    }  
    //2.1 当前同步队列尾节点为null，说明当前线程是第一个加入同步队列进行等待的线程  
    enq(node);
    return node;
}

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                // 1.获得当前节点的先驱节点
                final Node p = node.predecessor();
                // 2.当前节点能否获取独占式锁                    
                // 2.1 如果当前节点的先驱节点是头结点并且成功tryAcquire获取同步状态，即可以获得独占式锁
                if (p == head && tryAcquire(arg)) {
                    // 队列头指针用指向当前节点
                    setHead(node);
                    // 释放前驱节点
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                // 2.2 获取锁失败，线程进入等待状态，尝试park挂起
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
}

// 队列头结点引用指向当前节点，因为头结点是傀儡节点，所以相当于出队了
setHead(node);  
// 释放前驱节点
// 拆掉原头结点的next引用，指向它的prev引用在setHead()中已经拆掉
p.next = null; // help GC  
failed = false;  
return interrupted;

private void setHead(Node node) {
        head = node;
        node.thread = null;
        node.prev = null;
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    // 前驱节点为signal状态
    if (ws == Node.SIGNAL)
        /*
         * This node has already set status asking a release
         * to signal it, so it can safely park.
         */
        return true;
    // 前驱节点为cancel状态
    if (ws > 0) {
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        /*
         * waitStatus must be 0 or PROPAGATE.  Indicate that we
         * need a signal, but don't park yet.  Caller will need to
         * retry to make sure it cannot acquire before parking.
         */
        // 将前驱节点设置为signal，表示当前需要被唤醒
        // 相当于给自己设一个闹钟再去睡，这个闹钟会在恰当的时候叫醒自己
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

private final boolean parkAndCheckInterrupt() {
        //使得该线程阻塞
        LockSupport.park(this);
        return Thread.interrupted();
}

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) {
    /*
     * If status is negative (i.e., possibly needing signal) try
     * to clear in anticipation of signalling.  It is OK if this
     * fails or if status is changed by waiting thread.
     */
    int ws = node.waitStatus;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);

    /*
     * Thread to unpark is held in successor, which is normally
     * just the next node.  But if cancelled or apparently null,
     * traverse backwards from tail to find the actual
     * non-cancelled successor.
     */

    // 获取头节点的后继节点
    Node s = node.next;
   // 此后继节点为null或处于cancel状态
    if (s == null || s.waitStatus > 0) {
        s = null;
        // 通常情况下, 要唤醒的节点就是自己的后继节点
        // 如果后继节点存在且也在等待锁, 那就直接唤醒它
        // 但是有可能存在 后继节点是取消等待锁（ws>0）的情况
        // 此时从尾节点开始向前找起, 直到找到距离head节点最近的ws<=0的节点
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    if (s != null)
        // 后继节点不为null时唤醒节点对应线程
        LockSupport.unpark(s.thread);
}

public final void acquireShared(int arg) {
    if (tryAcquireShared(arg) < 0)
        doAcquireShared(arg);
}

private void doAcquireShared(int arg) {
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            final Node p = node.predecessor();
            // 当前节点的前驱节点是头结点并且tryAcquireShared()返回值大于等于0即表示能成功获得同步状态。
            if (p == head) {
                int r = tryAcquireShared(arg);
                if (r >= 0) {
                    // 当该节点的前驱节点是头结点且成功获取同步状态
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    if (interrupted)
                        selfInterrupt();
                    failed = false;
                    return;
                }
            }
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

private void setHeadAndPropagate(Node node, int propagate) {
    Node h = head; // Record old head for check below
    // 设置新的头节点就是为了让获取共享资源的操作传播下去
    setHead(node);
    if (propagate > 0 || h == null || h.waitStatus < 0) {
        Node s = node.next;
        // 如果下个节点为null或是共享的就进行释放
        if (s == null || s.isShared())
            doReleaseShared();
    }
}

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}

private void doReleaseShared() {
    /*
     * Ensure that a release propagates, even if there are other
     * in-progress acquires/releases.  This proceeds in the usual
     * way of trying to unparkSuccessor of head if it needs
     * signal. But if it does not, status is set to PROPAGATE to
     * ensure that upon release, propagation continues.
     * Additionally, we must loop in case a new node is added
     * while we are doing this. Also, unlike other uses of
     * unparkSuccessor, we need to know if CAS to reset status
     * fails, if so rechecking.
     */
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                    // 唤醒后续节点
                    unparkSuccessor(h);
            }
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

node.prev = pred;  
if (compareAndSetTail(pred, node)) {  
     pred.next = node;
     return node;
}  

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this); // 在这里被挂起了, 唤醒之后就能继续往下执行了
    return Thread.interrupted();
}

if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
    interrupted = true;

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

static void selfInterrupt() {
    Thread.currentThread().interrupt();
}