看本文建议结合源码
首先来看看ReentrantLock的构造方法，它的构造方法有两个，如所示：
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(booleanfair) {
sync = fair ? new FairSync() : new NonfairSync();
}
在ReentrantLock中定义了三个内部类，分别是Sync以及Sync的子类FairSync、NonfairSync，分别实现了公平策略和非公平策略，默认实现的是非公平策略。
公平和非公平的第一个区分点，首先来看NonfairSync的lock方法
finalvoid lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
假设有三个并发的线程，第一个线程调用lock的时候，compareAndSetState(0,1)是可以正常执行的返回true，然后把当前线程置为独占模式的当前所有者，然后该线程可以执行后续操作。如果第二个线程被放到队列中，第三个线程走到compareAndSetState(0,1)，第一个线程刚好unlock掉，那么第三个线程就会直接执行，而不是等待第二个线程执行后，这也就是非公平模式的特点。第二个线程调用lock的时候，compareAndSetState(0,1)返回false，执行acquire(1)，该方法会调用tryAcquire(1)和acquireQueued(addWaiter(Node.EXCLUSIVE), 1)
先来看下tryAcquire(1)，该方法的实现是nonfairTryAcquire方法,代码如下：
finalboolean nonfairTryAcquire(intacquires) {
final Thread current = Thread.currentThread();
intc = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
returntrue;
}
}
elseif (current == getExclusiveOwnerThread()) {
intnextc = c + acquires;
if (nextc < 0) // overflow
thrownew Error("Maximum lock count exceeded");
setState(nextc);
returntrue;
}
returnfalse;
}
看代码，结合三个线程并发的场景，第一个线程lock后，会把state（默认值是0）的值置为1，所以c的值现在是1，getExclusiveOwnerThread()是第一个线程，所以直接返回false，执行acquireQueued(addWaiter(Node.EXCLUSIVE), 1),方法addWaiter(Node.EXCLUSIVE)的作用是根据给的排他模式把当前线程（也就是第二个线程）加入队列中，此时的队列情况如下：
首次有线程（Node）进入队列时，会先new一个Node对象作为头部，然后把首次进队列的线程（Node）挂在其后面。Node对象是包含当前线程和模型的作为队列元素
然后执行acquireQueued(final Node node, int arg)，来看下代码：
finalboolean acquireQueued(final Node node, intarg) {
booleanfailed = true;
try {
booleaninterrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
returninterrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
第二个线程入队列，前面是一个初始化的对象也是head的值，进入循环后，会再次tryAcquire(1)，假设依然获取不到，则进入第二个if语句中，执行shouldParkAfterFailedAcquire(p, node)方法和parkAndCheckInterrupt()方法，parkAndCheckInterrupt()就会把第二个线程阻塞起来。
公平和非公平的第二个区分点在tryAcquire(int acquires)方法中，如下：
protectedfinalboolean tryAcquire(intacquires) {
final Thread current = Thread.currentThread();
intc = getState();
if (c == 0) {
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
returntrue;
}
}
elseif (current == getExclusiveOwnerThread()) {
intnextc = c + acquires;
if (nextc < 0)
thrownew Error("Maximum lock count exceeded");
setState(nextc);
returntrue;
}
returnfalse;
}
当第一个线程走完，第二个线程在队列中，第三个线程调用acquire(int arg)时先调用tryAcquire方法，会进行!hasQueuedPredecessors() && compareAndSetState(0, acquires)判断，而非公平的只有进行了compareAndSetState(0, acquires)判断，不考虑队列是否有等待的线程，而hasQueuedPredecessors()该方法就是判断队列中是否有阻塞的线程，如果有返回true，然后执行acquireQueued方法入队列。在第三个线程入队列同时，第一个线程走完调用unlock操作，该操作就会去调用release方法，如下
publicfinalboolean release(intarg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
returntrue;
}
returnfalse;
}
最终调用unparkSuccessor(h)方法，
privatevoid unparkSuccessor(Node node) {
intws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread);
}
从队列中获取第二个线程，unpark操作。阻塞结束后还在acquireQueued(final Node node, intarg)的循环体中，此时!hasQueuedPredecessors()和compareAndSetState(0, acquires)都为true，并把当前线程置为独占模式的当前所有者，然后该线程可以执行程序中lock()方法的后续操作。