Java高并发编程基础之AQS

// 头节点 
private transient volatile Node head; 
 
// 阻塞的尾节点，每个新的节点进来，都插入到最后，也就形成了一个链表 
private transient volatile Node tail; 
 
// 这个是最重要的，代表当前锁的状态，0代表没有被占用，大于 0 代表有线程持有当前锁 
// 这个值可以大于 1，是因为锁可以重入，每次重入都加上 1 
private volatile int state; 
 
// 代表当前持有独占锁的线程，举个最重要的使用例子，因为锁可以重入 
// reentrantLock.lock()可以嵌套调用多次，所以每次用这个来判断当前线程是否已经拥有了锁 
// if (currentThread == getExclusiveOwnerThread()) {state++} 
private transient Thread exclusiveOwnerThread; //继承自AbstractOwnableSynchronizer 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

final void lock() { 
           // 上来先试试直接把状态置位1，如果此时没人获取锁就直接 
           if (compareAndSetState(0, 1)) 
                // 争抢成功则修改获得锁状态的线程 
               setExclusiveOwnerThread(Thread.currentThread()); 
           else 
               acquire(1); 
       } 
1.
2.
3.
4.
5.
6.
7.
8.

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

final boolean nonfairTryAcquire(int acquires) { 
          final Thread current = Thread.currentThread(); 
           // 获取下当前锁的状态 
          int c = getState(); 
          // 这个if 逻辑跟前面一进来就获取锁的逻辑一样都是通过cas尝试获取下锁 
          if (c == 0) { 
              if (compareAndSetState(0, acquires)) { 
                  setExclusiveOwnerThread(current); 
                  return true; 
              } 
          } 
          // 进入这个判断说明 锁重入了 状态需要进行+1 
          else if (current == getExclusiveOwnerThread()) { 
              int nextc = c + acquires; 
               // 如果锁的重入次数大于int的最大值，直接就抛出异常了，正常情况应该不存在这种情况，不过jdk还是严谨的 
              if (nextc < 0) // overflow 
                  throw new Error("Maximum lock count exceeded"); 
              setState(nextc); 
              return true; 
          } 
          // 返回false 说明尝试获取锁失败了，失败了就要进行acquireQueued方法了 
          return false; 
      } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

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; 
           // cas 加入队列队尾 
           if (compareAndSetTail(pred, node)) { 
               pred.next = node; 
               return node; 
           } 
       } 
       // 尾结点不为空 || cas 加入尾结点失败 
       enq(node); 
       return node; 
   } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

// 通过自旋和CAS一定要当前node加入队尾 
private Node enq(final Node node) { 
        for (;;) { 
            Node t = tail; 
            // 尾结点为空说明队列还是空的，还没有被初始化，所以初始化头结点，可以看到头结点的node 是没有绑定线程的也就是不存数据的 
            if (t == null) { // Must initialize 
                if (compareAndSetHead(new Node())) 
                    tail = head; 
            } else { 
                node.prev = t; 
                if (compareAndSetTail(t, node)) { 
                    t.next = node; 
                    return t; 
                } 
            } 
        } 
    } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

final boolean acquireQueued(final Node node, int arg) { 
    boolean failed = true; 
    try { 
        boolean interrupted = false; 
        for (;;) { 
             // 通过自旋去获取锁 前驱节点==head的时候去尝试获取锁，这个方法在前面已经分析过了。 
            final Node p = node.predecessor(); 
            if (p == head && tryAcquire(arg)) { 
                setHead(node); 
                p.next = null; // help GC 
                failed = false; 
                return interrupted; 
            } 
           // 进入这个if说明node的前驱节点不等于head 或者尝试获取锁失败了 
           // 判断是否需要挂起当前线程 
            if (shouldParkAfterFailedAcquire(p, node) && 
                parkAndCheckInterrupt()) 
                interrupted = true; 
        } 
    } finally { 
           // 异常情况进入cancelAcquire，在jdk11的时候这个源码直接是catch (Throwable e){ cancelAcquire(node);} 简单明了 
        if (failed) 
            cancelAcquire(node); 
    } 
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { 
        int ws = pred.waitStatus; 
        // 前驱节点状态 如果这个状态为-1 则返回true，把当前线程挂起 
        if (ws == Node.SIGNAL) 
            return true; 
        // 大于0，说明状态为CANCELLED  
        if (ws > 0) { 
            do { 
               // 删除被取消的node（让被取消的node成为一个没有引用的node等着下次GC被回收） 
                node.prev = pred = pred.prev; 
            } while (pred.waitStatus > 0); 
            pred.next = node; 
        } else { 
            // 进入这里只能是 0，-2，-3。NODE节点初始化的时候waitStatus默认值是0，所以只有这里才有修改waitStatus的地方 
            // 通过cas 把前驱节点的状态设置为-1，然后返回false ，外面调用这个方法的是个循环，又会调用一次这个方法 
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL); 
        } 
        return false; 
    } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

private final boolean parkAndCheckInterrupt() { 
    LockSupport.park(this); // 挂起当前线程，阻塞 
    return Thread.interrupted(); 
} 
1.
2.
3.
4.

private void unparkSuccessor(Node node) { 
         // 头结点状态 
       int ws = node.waitStatus; 
       if (ws < 0) 
           compareAndSetWaitStatus(node, ws, 0); 
       Node s = node.next; 
       // s==null head的successor节点获取锁成功后，执行了head.next=null的操作后，解锁线程读取了head.next，因此s==null 
       // head的successor节点被取消（cancelAcquire）时，执行了如下操作：successor.waitStatus=1 ; successor.next = successor; 
       if (s == null || s.waitStatus > 0) { 
           s = null; 
           // 从尾节点开始往前找，找到最前面的非取消的节点 这里没有break 哦 
           for (Node t = tail; t != null && t != node; t = t.prev) 
               if (t.waitStatus <= 0) 
                   s = t; 
       } 
       if (s != null) 
            // 唤醒线程 ，唤醒的线程会从acquireQueued去获取锁 
           LockSupport.unpark(s.thread); 
   } 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.