Java并发中的fairSync和NonfairSync主要区别为：
如果当前线程不是锁的占有者,则NonfairSync并不判断是否有等待队列,直接使用compareAndSwap去进行锁的占用;
如果当前线程不是锁的占有者,则FairSync则会判断当前是否有等待队列,如果有则将自己加到等待队列尾;
对应的源码如下：
AbstractQueuedSynchronizer）：
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//判断是否有等待队列,没有队列时，进行占用，如果占用失败,将自己加到等待队列尾
if(!hasQueuedPredecessors() &&
compareAndSetState(
0
, acquires)) {
return true
;
}
setExclusiveOwnerThread(current);
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
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;
};
NonFairSync：
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {//不判断是否有等待队列,直接进行占用,如果占用失败也进到等待队列尾
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
占用失败后，将自己加到等待队列尾的动作在AbstractQueuedSynchronizerder类acquire方法中:
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
由于FairSync和NonFairSync均继承AbstractQueuedSynchronizerder(AQS)，
这里使用了到了一个设计模式（模板模式）来设计NonFairSync和FairSync类
