（原创）多线程并发：AQS源码分析（1）——独占锁的实现原理

    public final void acquire(int arg) {
        /*尝试获取共享资源，尝试成功直接返回*/
        if (!tryAcquire(arg)  
                /* 1、抢占共享资源失败，则将当前节点放入到同步队列的尾部，并标记为独占模式；
                 * 2、使线程阻塞在同步队列中获取资源，直到获取成功才返回；如果整个过程中被中断过就返回true，否则就返回false；*/
                && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
            /*阻塞获取资源的过程中是不响应线程中断的，内部进行了中断检测，检测到了中断请求，所以这块进行线程中断*/
            selfInterrupt();
        }
    }

private Node addWaiter(Node mode) {
        /*以给定的模式将当前线程包装成node节点*/
        Node node = new Node(Thread.currentThread(), mode);
        /*快速采用尾插法，将当前节点插入到同步队列的队尾*/
        Node predNode = tail;
        if (predNode != null) {
            /*preNode <-- node*/
            node.prev = predNode;
            /*采用CAS将node设置阻塞队列的尾节点，设置成功，说明没有并发*/
            if (compareAndSetTail(tail, node)) {
                predNode.next = node;
                /*尾插法插入成功，则直接返回当前节点*/
                return node;
            }
        }
        /*"自旋"将节点加入到队列的尾部，直到成功为止*/
        enq(node);
        return node;
    }

 private Node enq(final Node node) {
        /*"自旋"，将给定的节点插入到同步队列的尾部*/
        for (;;) {
            Node t = tail;
            /*同步队列为空，则创建一个thread为null的Node节点作为同步队列的头结点，并且将尾节点也设置为头结点*/
            if (t == null) {
                /*CAS操作，设置同步队列的头结点*/
                if (compareAndSetHead(new Node())) {
                    /*将尾节点设置为头结点，进入下次"自旋"*/
                    tail = head;
                }
            }else {
                /*尾部节点不为空，则进行正常添加动作*/
                node.prev = t;
                /*CAS操作，设置同步队列的头结点*/
                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();
                /*1、前驱结点是头结点，则说明当前线程有资格获取共享资源，尝试获取，获取成功，将当前节点设置为头结点*/
                if (p == head && tryAcquire(arg)) {
                    /*将当前节点设置为头结点*/
                    setHead(node);
                    p.next = null; //help GC
                    failed = false;
　　　　　　　　　　　　/*返回线程在阻塞的过程中是否接受到了中断请求*/
                    return interrupted;
                }
                
                /*2、3当前节点的前驱结点不是头结点，判断当前线程是否可以挂起*/
                if (shouldParkAfterFailedAcquire(p, node)
                        /*4、当前线程可以挂起，则挂起线程，并且线程被unpark()或者interrupt()唤醒，检查线程的状态*/
                        && parkAndCheckInterrupt()) {
                    interrupted = true;
                }
            }
        }finally{
　　
            if (failed) {
                /*5、阻塞获取同步资源的时候，发生了异常，将当前Node节点从同步队列中出队*/
                cancelAcquire(node);
            }
        }

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        /*判断前驱结点的状态，只有前驱结点的状态为SIGNAL,后继节点才能被唤醒，所以其可以安心地挂起来了*/
        if (ws == node.waitStatus) {
            return true;
        }
        
        /*ws>0表示前驱结点中的线程已经被取消调度了，则认为其是无效节点，继续向前查找，直至找到有效状态的节点*/
        if (ws > 0) {
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        }else {
            /*前驱结点状态正常，将前驱结点状态设置为SIGNAL,则前驱结点释放资源的时候，就可以尝试唤醒当前这个后继节点了*/
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }

    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);
        return Thread.interrupted();
    }

 1     private void cancelAcquire(Node node) {
 2         //当前节点为空，则说明当前线程永远不会被调度到了，所以直接返回
 3         if (node == null) {
 4             return;
 5         }
 6         
 7         /**
 8          * 接下来将点前Node节点从同步队列出队，主要做以下几件事：
 9          * 1、将当前节点不与任何线程绑定，设置当前节点为Node.CANCELLED状态；
10          * 2、将当前取消节点的前置非取消节点和后置非取消节点"链接"起来；
11          * 3、如果前置节点释放了锁，那么当前取消节点承担起后续节点的唤醒职责。
12          */
13         
14         //1、取消当前节点与线程的绑定
15         node.thread = null;
16         
17         //2、找到当前节点的有效前继节点pred
18         Node pred = node.prev;
19         while (pred.waitStatus > 0) {
20             //为什么双向链表从后往前遍历呢？而不是从前往后遍历呢？
21             node.prev = pred = pred.prev;
22         }
23         //用作CAS操作时候的条件判断需要使用的值
24         Node predNext = pred.next;
25         
26         //3、将当前节点设置为取消状态
27         node.waitStatus = Node.CANCELLED;
28         
29         /**
30          * 接下来就需要将当前取消节点的前后两个有效节点"链接"起来了，"达成让当前node节点出队的目的"。
31          * 这里按照node节点在同步队列中的不同位置分了三种情况：
32          * 1、node节点是同步队列的尾节点tail;
33          * 2、node节点既不是同步队列头结点head的后继节点，也不是尾节点tail;
34          * 3、node节点是同步队列头结点head的后继节点；
35          */
36         
37         //1、node是尾节点，并且执行过程中没有并发，直接将pred设置为同步队列的tail
38         if (node == tail && compareAndSetTail(node, pred)) {
39             /*
40              * 此时pred已经设置为同步队列的tail，需要通过CAS操作，将pred的next指向null,没有节点再引用node，就完成了node节点的出队42              */
43             compareAndSetNext(pred, predNext, null);
44         }else {
45             /*
46              * 2、node不是尾节点，也不是头结点head的后继节点,那么当前节点node出队以后，node的有效前继结点pred，
47              *  就有义务在它自身释放资源的时候，唤醒node的有效后继节点successor,即将pred的状态设置为Node.SIGNAL;
48              */
49             int ws;
50             //能执行到这里，说明当前node节点不是head的后继节点，也不是同步队列tail节点
51             if (pred != head &&
52                     ((ws = pred.waitStatus) == Node.SIGNAL ||
53                     //前继节点状态虽然有效但不是SIGNAL,采用CAS操作设置为SIGNAL确保后继有效节点可以被唤醒
54                     (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) && 
55                     pred.thread != null) {
56                 Node next = node.next;
57                 //只负责唤醒有效后继节点
58                 if (next != null && next.waitStatus <= 0) {
59                     /**
60                      * 下面这段代码相当于将pred-->next，我们提到这个同步队列是个双向队列，那么pred<--next这是谁执行的呢？
61                      * 答案是其他线程：其它线程在后序的获取共享资源在同步队列中阻塞的时候，调用shouldParkAfterFailedAcquire()方法，
62                      * 从后向前遍历队列，寻找能唤醒它的有效前继节点，当找到node的时候，因为它的状态已经是Node.CANCELLED,所以会忽略node节点，
63                      * 直到遍历到有效前继节点pred,将next.prev执行pred,即next--->pred，没有节点再引用node节点，所以node节点至此才完成出队。
64                      */
65                     compareAndSetNext(pred, predNext, next);
66                 }
67             }else {
68                 //3、说明node节点是同步队列head的后继节点，调用unparkSuccessor(Node)唤醒其他线程，达到让当前node"出队"。
69                 unparkSuccessor(node);
70             }
71             
72             node.next = node;//help GC
73         }
74     }

 1   private void unparkSuccessor(Node node) {
 2         /*
 3          * If status is negative (i.e., possibly needing signal) try
 4          * to clear in anticipation of signalling.  It is OK if this
 5          * fails or if status is changed by waiting thread.
 6          */
 7         //在这里，这个节点其实是同步队列的头结点，头结点唤醒后继节点之后，使命就完成了，所以应该将其状态置为0
 8         int ws = node.waitStatus;
 9         if (ws < 0)
10             compareAndSetWaitStatus(node, ws, 0);
11 
12         /*
13          * Thread to unpark is held in successor, which is normally
14          * just the next node.  But if cancelled or apparently null,
15          * traverse backwards from tail to find the actual
16          * non-cancelled successor.
17          */
18         Node s = node.next;
19         //因为s.next相当于从同步队列的头部遍历所以可能会出现s == null的情况，上面分析过原因，不再赘述了。
20         if (s == null || s.waitStatus > 0) {
21             s = null;
22             //从同步队列的尾部向前遍历，找到当前node节点(头结点)的最近的有效后继节点
23             for (Node t = tail; t != null && t != node; t = t.prev)
24                 if (t.waitStatus <= 0)
25                     s = t;
26         }
27         
28         /**
29          * 找到最近的有效后继节点，则唤醒后继节点中的线程在parkAndCheckInterrupt()方法上的阻塞，去尝试竞争共享资源，
30          * 这就体现了线程之间的协作，而在这个竞争的过程中也会忽略这个Node.CANCELLED状态的节点，这当前node节点也就放弃了竞争共享资源的机会，相当于出队了。
31          */
32         if (s != null)
33             LockSupport.unpark(s.thread);
34     }