ReentrantLock中公平锁与非公平锁的区别

ReentrantLock:通过模板模式使用Sync继承了AbstractQueuedSynchronizer(同步器)
，继而又使用了FairSync，NonFairSync类来覆写了Sync的方法，
在使用ReentrantLock时，通过构造方法确定使用公平锁还是非公平锁。
公平锁与非公平锁的差别主要在获取锁时：

公平锁：
//首先直接调用acquire方法
 final void lock() {
            acquire(1);
        }

//acquire为Sync类的获取锁的核心方法
public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }
//tryAcquire方法为公平锁与非公平锁的核心区别	
	
protected final boolean tryAcquire(int acquires) {
	final Thread current = Thread.currentThread();
	int c = getState();
	if (c == 0) {
	//此处!hasQueuedPredecessors()方法判断了
	//同步队列中是否有线程节点，如果有，直接将正在竞争锁的线程
	//入队，如果为空队列，才尝试CAS争夺锁
		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;
}

//非公平锁
final void lock() {
	//掉用lock后，直接尝试CAS获取对象锁
	if (compareAndSetState(0, 1))
		setExclusiveOwnerThread(Thread.currentThread());
	//CAS获取失败，才使用acquire方法获取锁
	else
		acquire(1);
}


//非公平锁的tryAcquire方法


final boolean nonfairTryAcquire(int acquires) {
	final Thread current = Thread.currentThread();
	int c = getState();
	if (c == 0) {
		//进行CAS尝试获取锁
		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;
}

公平锁与非公平锁的区别点：

公平锁：在lock()时，直接调用acquire(),
然后在tryAcquire()时，首先判断同步队列是否为空，
如果为空，CAS争夺锁，如果不为空，直接将当前线程包装为节点入队
优缺点：它保证了请求资源时间上的绝对顺序，但是需要频繁的上下文切换，开销较大

非公平锁：在lock()时尝试获取锁，
在tryAcquire()时，直接尝试CAS获取锁，与同步队列进行锁的竞争
优缺点：降低了一定的上下文切换，降低了性能开销，但是可能刚释放锁的线程下次继续获取该锁，可能导致其他线程永远无法获取到锁，造成“饥饿现象”

ReentrantLock默认使用的是非公平锁哦，减少了一定的上下文切换，它保证了系统更大的吞吐量

ps：上下文切换：线程的阻塞与唤醒的切换，需要操作系统从用户态到内核态开销较大。