组成结构
ReentrantLock有三个内部类，如下：
其中，FairSync是公平锁，NofairSync是非公平锁，FairSync与NofairSync都继承于Sync。
那么，什么是公平锁与非公平锁呢？
公平锁：当前线程不去获得锁，而是进入等待队列的队尾等待获取锁。
非公平锁：先去尝试获取锁，如果获取不到，再去队尾排队获取锁。
非公平锁执行代码解析
当调用lock()方法的时候，默认执行的是非公平锁的lock方法，很明显，非公平锁的效率是优于公平锁的
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
首先，根据CAS锁判断，如果返回true，则当前线程抢占这个锁，如果返回false，执行acquire()方法。
那么，什么是CAS锁？
CAS锁
CAS，全称为 Compare And Swap，是一条原子指令，直接由cpu来完成。进入compareAndSetState()方法之中。
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
我们可以看到，这个方法直接调用了Unsafe类的CompareAndSwapInt()方法，这是一个native方法，只有当前值等于期望值的时候，返回true，如果不同，返回false，也就是说当前线程进入获得锁后，其他线程需要判断是否已经改变，而且是在硬件层面实现的，JVM也只是利用汇编来使用而已。
但是CAS是有缺陷的，比如ABA的情况，cpu处理是需要时间的，CAS操作需要读取数值，与期望值对比，在这段时间内，是可能出现其他线程进入修改，又改回来的情况，解决方案：加入一个变量，每次线程进入时加一，在线程进入同时，判断变量是否被修改过。
我们继续回来
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
如果当前锁已经被占用，就调用acquire()方法。
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
尝试获取锁，同时将，当前线程加入等待队列的末尾
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
tryAcquire()方法调用nofairTryAcquire()方法。
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;
}
这个方法，判断state的值，如果state的值为0的话，再进行一次CAS锁判断，如果返回true，将当前锁设置为独占锁，为当前线程所有。
接下来进入addWaiter()方法之中，方法内容如下：
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
判断当前队列的尾节点是不是null，如果不为空，将尾节点赋值给当前节点的prev属性，如果是空，说明这是一个空队列，执行enq()方法。
private Node enq(final Node node) {
for (;;) {
Node t = tail;
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
这是一个无限循环，如果尾节点为null，进行一次CAS判断再次判断Node对象是不是null，如果返回true，尾节点即为头结点。如果尾节点不为null，将当前线程放入队列，并且作CAS判断，向队列尾部添加当前线程。
返回来，执行acquireQueued()：
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
当且仅当，当前节点的前一个节点等于头结点时，才能尝试获取锁，当二者都满足时，把当前节点设为头结点，当前节点的next置为null，方便垃圾回收，返回false。下面执行方法shouldParkAfterFailedAcquire()判断当前线程是否可以被安全的挂起。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
return true;
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
！tryAcquire()与acquireQueued()方法返回true，执行中断。
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
公平锁部分与非公平锁大同小异，在此不再赘述。
