ReentrantLock

ReentrantLock作为java.util.concurrent.locks中重要的一个锁，是很值得初学者研究的，现在就以一位初学者的视角来看ReentrantLock的主要原理

底层数据结构

根据类图（IDEA中ALT+SHIFT+CTRL+U）可以看出重入锁是分为FairSync（公平）和NonfairSync（非公平）的。

/** Synchronizer providing all implementation mechanics */
// 真正的锁机制是基于AQS实现的private final Sync sync;public ReentrantLock() {sync = new NonfairSync();}public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();}

在初始化时，如果不传参数，则默认初始化非公平锁。

 /*** The synchronization state.*/private volatile int state;

这个state在AbstractQueuedSynchronizer中定义。意思是重入了几次。

公平？非公平

公平的意思是指当线程获取锁时需要进行排队，排到你的时候你才能获取锁。
非公平的意思是指线程在获取锁的时候可以进行插队，如果插队失败再排队。

lock()

重入锁的lock()行为是由sync决定。

FairSync 时

	final void lock() {acquire(1);}public final void acquire(int arg) {if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}

可以看见尝试设置state为1
首先来分析tryAcquire

		protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread(); // 获取当前调用的线程int c = getState(); // 获取当前AQS重入的次数if (c == 0) { // 如果为0 说明没有人使用这把锁if (!hasQueuedPredecessors() && // 如果自己前面没有人排队了，尝试CAS设置重入次数为1compareAndSetState(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;}/*** 判断是否队列中存在排队线程*/public final boolean hasQueuedPredecessors() {// The correctness of this depends on head being initialized// before tail and on head.next being accurate if the current// thread is first in queue.Node t = tail; // Read fields in reverse initialization orderNode h = head;Node s;return h != t && // head 和 tail 不同 并且 head的后一个为空 或者 后一个和调用线程不是同一个就返回true((s = h.next) == null || s.thread != Thread.currentThread());}

经过上面一通操作，如果失败则需要调用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)) { // 如果前驱节点为头并且设置成功了，则将当前的线程节点置为headsetHead(node);p.next = null; // help GCfailed = false;return interrupted;}if (shouldParkAfterFailedAcquire(p, node) && // 接入队列成功，然后阻塞自己，等待其他人来唤醒parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}}private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {int ws = pred.waitStatus; // 当前线程节点的前驱等待状态if (ws == Node.SIGNAL) // 如果是SIGNAL，说明可以在当前锁持有者release时通知它。return true;if (ws > 0) { // 说明状态为CANCELLED = 1,需要进行跳过，找到新的等待中的前驱节点do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);pred.next = node; // 接到前驱节点后面} else { // 状态一定为0 或者 PROPAGATE，我们需要在阻塞前尝试一次状态变更  compareAndSetWaitStatus(pred, ws, Node.SIGNAL);}return false;}

NonfairSync 时

	final void lock() {if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);}

可以看出，在FairSync的acquire之前进行了一次CAS，如果成功也就意味着抢到了锁，体现了非公平的性质。那么NonfairSync的acquire和FairSync的一样吗？
首先还是同样的代码

 	public final void acquire(int arg) {if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}

发现有一点点不同了

	protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);}final boolean nonfairTryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {if (compareAndSetState(0, acquires)) { // FairSync时是需要判断是否当前节点就是Head的，而NonFairSync就没有判断setExclusiveOwnerThread(current);return true;}}else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");setState(nextc);return true;}return false;}

acquireQueued() 的代码和FairSync的一致就不贴了，主要还是这个tryAcquire的不同。正是这个不同导致公平锁模式需要老实排队，而非公平锁则有机会插队。

unlock()

	public void unlock() {sync.release(1);}

这个解锁就和公平不公平没有关系了

 	public final boolean release(int arg) {if (tryRelease(arg)) {Node h = head;if (h != null && h.waitStatus != 0)unparkSuccessor(h);return true;}return false;}

发现调用tryRelease

		protected final boolean tryRelease(int releases) {int c = getState() - releases; // 计算新的重入次数if (Thread.currentThread() != getExclusiveOwnerThread()) // 如果当前线程和持有者不一致，抛出异常throw new IllegalMonitorStateException();boolean free = false;if (c == 0) { // 如果重入次数为0了，说明已经没人使用了，需要将持有者设置为nullfree = true;setExclusiveOwnerThread(null);}setState(c);return free;}

CAS

cas是指Compare-And-Swap，底层调用UnSafe类的public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);其中var1是对象在JVM中地址（猜的），var2是对象相对于内存的偏移量，var4是期待值，var5是新值，当期待值和和对象真实值一致的时候，将对象值设置成新值。
在C的实现中可以看到Atomic::cmpxchg(x,addr,e)这是一条原子指令，因此保证CAS的原子性。