基于 AbstractQueuedSynchronizer 的并发类实现（2）

look_w

接着，看一下公平锁的实现，FairSync类，它继承自Sync：

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

static final class FairSync extends Sync {     private static final long serialVersionUID = -3000897897090466540L;     final void lock() {         acquire(1);     }     /**      * Fair version of tryAcquire.  Don't grant access unless      * recursive call or no waiters or is first.      */     protected final boolean tryAcquire(int acquires) {         final Thread current = Thread.currentThread();         int c = getState();         if (c == 0) {             if (!hasQueuedPredecessors() &&                 compareAndSetState(0, acquires)) {                 setExclusiveOwnerThread(current);                 return true;             }         }         else if (current == getExclusiveOwnerThread()) {             int nextc = c + acquires;             if (nextc < 0)                 throw new Error("Maximum lock count exceeded");             setState(nextc);             return true;         }         return false;     } }

整理一下要点：
1. 每次acquire的时候，state+1，如果当前线程lock()之后又lock()了，state不断+1，相应的unlock()的时候state-1，直到将state减到0为之，说明当前线程释放完所有的状态，其它线程可以竞争
2. state=0的时候，通过hasQueuedPredecessors方法做一次判断，hasQueuedPredecessors的实现为”h != t && ((s = h.next) == null || s.thread != Thread.currentThread());”，其中h是head、t是tail，由于代码中对结果取反，因此取反之后的判断为”h == t || ((s = h.next) != null && s.thread == Thread.currentThread());”，总结起来有两种情况可以通过!hasQueuedPredecessors()这个判断：

• h==t，h==t的情况为要么当前FIFO队列中没有任何数据，要么只构建出了一个head还没往后面连过任何一个Node，因此head就是tail
• (s = h.next) != null && s.thread == Thread.currentThread()，当前线程为正在等待的第一个Node中的线程

3. 如果没有线程比当前线程等待更久去执行acquire操作，那么通过CAS操作将state从0变为1的线程tryAcquire成功
4. 没有tryAcquire成功的线程，按照tryAcquire的先后顺序，构建为一个FIFO队列，即第一个tryAcquire失败的排在head的后一位，第二个tryAcquire失败的排在head的后二位
5. 当tryAcquire成功的线程release完毕，第一个tryAcquire失败的线程第一个尝试tryAcquire，这就是先到先得，典型的公平锁