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

look_w

再看下公平信号量的实现，同样的FairSync，继承自Sync，代码为：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

static final class FairSync extends Sync {     private static final long serialVersionUID = 2014338818796000944L;     FairSync(int permits) {         super(permits);     }     protected int tryAcquireShared(int acquires) {         for (;;) {             if (hasQueuedPredecessors())                 return -1;             int available = getState();             int remaining = available - acquires;             if (remaining < 0 ||                 compareAndSetState(available, remaining))                 return remaining;         }     } }

首先第10行的hasQueuedPredecessors方法，前面已经说过了，如果已经有了FIFO队列或者当前线程不是FIFO队列中在等待的第一条线程，返回-1，表示无法获取共享锁成功。
接着获取available，available就是state，用volatile修饰，所以线程中可以看到最新的state，信号量的acquires是1，每次获取信号量都对state-1，两种情况直接返回：

• remaining减完<0
• 通过cas设置成功

之后就是和之前说过的共享锁的逻辑了，如果返回的是一个<0的数字，那么构建FIFO队列，线程阻塞，直到前面的执行完才能唤醒后面的。
接着看一下非公平信号量的实现，NonfairSync继承Sync：

1 2 3 4 5 6 7 8 9 10 11

static final class NonfairSync extends Sync {     private static final long serialVersionUID = -2694183684443567898L;     NonfairSync(int permits) {         super(permits);     }     protected int tryAcquireShared(int acquires) {         return nonfairTryAcquireShared(acquires);     } }

nonfairTryAcquireShared在父类已经实现了，再贴一下代码：

1 2 3 4 5 6 7 8 9

final int nonfairTryAcquireShared(int acquires) {     for (;;) {         int available = getState();         int remaining = available - acquires;         if (remaining < 0 ||             compareAndSetState(available, remaining))             return remaining;     } }

看到这里和公平Semaphore只有一点差别：不会前置进行一次hasQueuedPredecessors()判断。即当前有没有构建为一个FIFO队列，队列里面第一个等待的线程是不是自身都无所谓，对于非公平Semaphore都一样，反正线程调用Semaphore的acquire方法就将当前state-1，如果得到的remaining设置成功或者CAS操作成功就返回，这种操作没有遵循先到先得的原则，即非公平信号量。
至于非公平信号量对比公平信号量的优点，和ReentrantLock的非公平锁对比ReentrantLock的公平锁一样，就不说了。