AQS ,模板方法

参考https://www.javadoop.com/post/AbstractQueuedSynchronizer

 提到的 ReentrantLock，Semaphore，其他的诸如 ReentrantReadWriteLock，SynchronousQueue，FutureTask 等等皆是基于 AQS 的

 

 

1、重要属性    头结点  +  尾节点  +  state  +  当前持有独占锁的线程

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// 头结点，你直接把它当做 当前持有锁的线程 可能是最好理解的 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

 

2、实际的阻塞队列，是不包含头结点的

 

3、结点Node的属性     

共享or独占   

状态，记录的是下一个节点的状态  CANCELLED =1  线程取消     SIGNAL=-1 表示下一个节点需要被唤醒   CONDITION表示是条件队列节点用在Condition类中   

前结点+后结点指针

线程本身  

 

注：状态waitStatus，初始值为0。头结点初始为0，当有一个排队时，把头结点waitStatus改为-1.“waitStatus代表后继节点的状态”

?

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 26 27 28 29 30 31 32 33 34 35 36 37

static final class Node {     // 标识节点当前在共享模式下     static final Node SHARED = new Node();     // 标识节点当前在独占模式下     static final Node EXCLUSIVE = null;       // ======== 下面的几个int常量是给waitStatus用的 ===========     /** waitStatus value to indicate thread has cancelled */     // 代码此线程取消了争抢这个锁     static final int CANCELLED =  1;     /** waitStatus value to indicate successor's thread needs unparking */     // 官方的描述是，其表示当前node的后继节点对应的线程需要被唤醒     static final int SIGNAL    = -1;     /** waitStatus value to indicate thread is waiting on condition */     // 本文不分析condition，所以略过吧，下一篇文章会介绍这个     static final int CONDITION = -2;     /**      * waitStatus value to indicate the next acquireShared should      * unconditionally propagate      */     // 同样的不分析，略过吧     static final int PROPAGATE = -3;     // =====================================================         // 取值为上面的1、-1、-2、-3，或者0(以后会讲到)     // 这么理解，暂时只需要知道如果这个值 大于0 代表此线程取消了等待，     //    ps: 半天抢不到锁，不抢了，ReentrantLock是可以指定timeouot的。。。     volatile int waitStatus;     // 前驱节点的引用     volatile Node prev;     // 后继节点的引用     volatile Node next;     // 这个就是线程本尊     volatile Thread thread;   }

 

4、抢锁    

总结：公平锁和非公平锁只有两处不同：

1. 非公平锁在调用 lock 后，首先就会调用 CAS 进行一次抢锁，如果这个时候恰巧锁没有被占用，那么直接就获取到锁返回了。
2. 非公平锁在 CAS 失败后，和公平锁一样都会进入到 tryAcquire 方法，在 tryAcquire 方法中，如果发现锁这个时候被释放了（state == 0），非公平锁会直接 CAS 抢锁，但是公平锁会判断等待队列是否有线程处于等待状态，如果有则不去抢锁，乖乖排到后面。

公平锁和非公平锁就这两点区别，如果这两次 CAS 都不成功，那么后面非公平锁和公平锁是一样的，都要进入到阻塞队列等待唤醒。

相对来说，非公平锁会有更好的性能，因为它的吞吐量比较大。当然，非公平锁让获取锁的时间变得更加不确定，可能会导致在阻塞队列中的线程长期处于饥饿状态。

 

 

 

5、增加到阻塞队列中addWriter，成功添加后将线程设置为等待状态，lockSupport.park

 

 

a、当队列不为空且或者CAS成功，则把生成的节点，插到队尾，用CAS把自己设置成队尾节点

b、pred==null(队列是空的) 或者 CAS失败(有线程在竞争入队)，进enq(node)，

c、进入自旋锁，如果头结点为空，则compareAndSetHead(new Node())，new出一个头结点，state = 0；不为空，则尝试CAS插入结点

?

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 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

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加到链表的最后面去，也就是进到阻塞队列的最后         Node pred = tail;           // tail!=null => 队列不为空(tail==head的时候，其实队列是空的，不过不管这个吧)         if (pred != null) {             // 将当前的队尾节点，设置为自己的前驱             node.prev = pred;             // 用CAS把自己设置为队尾, 如果成功后，tail == node 了，这个节点成为阻塞队列新的尾巴             if (compareAndSetTail(pred, node)) {                 // 进到这里说明设置成功，当前node==tail, 将自己与之前的队尾相连，                 // 上面已经有 node.prev = pred，加上下面这句，也就实现了和之前的尾节点双向连接了                 pred.next = node;                 // 线程入队了，可以返回了                 return node;             }         }         // 仔细看看上面的代码，如果会到这里，         // 说明 pred==null(队列是空的) 或者 CAS失败(有线程在竞争入队)         // 读者一定要跟上思路，如果没有跟上，建议先不要往下读了，往回仔细看，否则会浪费时间的         enq(node);         return node;     }       /**      * Inserts node into queue, initializing if necessary. See picture above.      * @param node the node to insert      * @return node's predecessor      */     // 采用自旋的方式入队     // 之前说过，到这个方法只有两种可能：等待队列为空，或者有线程竞争入队，     // 自旋在这边的语义是：CAS设置tail过程中，竞争一次竞争不到，我就多次竞争，总会排到的     private Node enq(final Node node) {         for (;;) {             Node t = tail;             // 之前说过，队列为空也会进来这里             if (t == null) { // Must initialize                 // 初始化head节点                 // 细心的读者会知道原来 head 和 tail 初始化的时候都是 null 的                 // 还是一步CAS，你懂的，现在可能是很多线程同时进来呢                 if (compareAndSetHead(new Node()))                     // 给后面用：这个时候head节点的waitStatus==0, 看new Node()构造方法就知道了                       // 这个时候有了head，但是tail还是null，设置一下，                     // 把tail指向head，放心，马上就有线程要来了，到时候tail就要被抢了                     // 注意：这里只是设置了tail=head，这里可没return哦，没有return，没有return                     // 所以，设置完了以后，继续for循环，下次就到下面的else分支了                     tail = head;             } else {                 // 下面几行，和上一个方法 addWaiter 是一样的，                 // 只是这个套在无限循环里，反正就是将当前线程排到队尾，有线程竞争的话排不上重复排                 node.prev = t;                 if (compareAndSetTail(t, node)) {                     t.next = node;                     return t;                 }             }         }     }

　　

6、解锁，release，只是把state-1了，减到0说明完全释放了锁

?

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 26

public final boolean release(int arg) {     // 往后看吧     if (tryRelease(arg)) {         Node h = head;         if (h != null && h.waitStatus != 0)             unparkSuccessor(h);         return true;     }     return false; }   // 回到ReentrantLock看tryRelease方法 protected final boolean tryRelease(int releases) {     int c = getState() - releases;     if (Thread.currentThread() != getExclusiveOwnerThread())         throw new IllegalMonitorStateException();     // 是否完全释放锁     boolean free = false;     // 其实就是重入的问题，如果c==0，也就是说没有嵌套锁了，可以释放了，否则还不能释放掉     if (c == 0) {         free = true;         setExclusiveOwnerThread(null);     }     setState(c);     return free; }

 

7、唤醒后继节点，需要进去判断state，如果是1取消则跳过

?

1	LockSupport.unpark（）   唤醒

?

1	LockSupport.park（）  阻塞

?

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 26 27 28 29 30

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;     // 如果head节点当前waitStatus<0, 将其修改为0     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.      */     // 下面的代码就是唤醒后继节点，但是有可能后继节点取消了等待（waitStatus==1）     // 从队尾往前找，找到waitStatus<=0的所有节点中排在最前面的     Node s = node.next;     if (s == null || s.waitStatus > 0) {         s = null;         // 从后往前找，仔细看代码，不必担心中间有节点取消(waitStatus==1)的情况         for (Node t = tail; t != null && t != node; t = t.prev)             if (t.waitStatus <= 0)                 s = t;     }     if (s != null)         // 唤醒线程         LockSupport.unpark(s.thread); }

　　

 

以 ReentrantLock 为例，state 初始化为 0，表示未锁定状态。A 线程 lock()时，会调用 tryAcquire()独占该锁并将 state+1。此后，其他线程再 tryAcquire()时就会失败，直到 A 线程 unlock()到 state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A 线程自己是可以重复获取此锁的（state 会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证 state 是能回到零态的。

再以 CountDownLatch 以例，任务分为 N 个子线程去执行，state 也初始化为 N（注意 N 要与线程个数一致）。这 N 个子线程是并行执行的，每个子线程执行完后 countDown()一次，state 会 CAS(Compare and Swap)减 1。等到所有子线程都执行完后(即 state=0)，会 unpark()主调用线程，然后主调用线程就会从 await()函数返回，继续后余动作。

 

AQS 使用了模板方法模式，自定义同步器时需要重写下面几个 AQS 提供的模板方法：

isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。