由于公司现在的架构师微服务，每个服务都需要进行分布式部署，对于一些功能，可能就需要考虑用分布式锁，分布式锁的实现方案有很多种，为了更升入的理解，楼主考虑深度的学习下jdk的可重入锁ReentrantLock

   打开ReentrantLock的源码便发现 它内部实现了aqs，通过继承aqs实现了公平锁Sync，非公平锁NonfairSync

说到这我介绍下什么是aqs

aqs 是一个抽象队列同步器，设计模式是模板模式。
核心数据结构：双向链表 + state(锁状态)
底层操作：CAS

首先介绍以下它的设计模式，我们加锁的时候调用 lock()方法，如下代码

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

通过代码跟踪，我们发现acquire 里面的tryAcquire 方法并没有实现，但定义了一个完整的流程，tryacquire 是在子类里面实现的

我们通过跟踪代码来看一下 公平锁的实现

   static final class FairSync extends Sync {private static final long serialVersionUID = -3000897897090466540L;final void lock() {acquire(1);}protected final boolean tryAcquire(int acquires) {final Thread current = Thread.currentThread();int c = getState();if (c == 0) {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;}}
}

这段代码我们看到了我们上面提到的state， state是干嘛用的呢？

 通过设置state状态标识锁有没有被占用，当state>0 时，表示锁被占用，当state=0 时，表示锁空闲，可以被获取，state是一个全局变量，设计到可见性问题，因此我们看源码

private volatile int state; 定义state 用了 volatile 保证可见性

我们在研究这段代码 当state=0 时，并且当前线程在头节点时，便可以获取锁，并设置新的state 状态， compareAndSetState(0, acquires))，我们深入这个代码

   /*** Atomically sets synchronization state to the given updated* value if the current state value equals the expected value.* This operation has memory semantics of a {@code volatile} read* and write.** @param expect the expected value* @param update the new value* @return {@code true} if successful. False return indicates that the actual*         value was not equal to the expected value.*/protected final boolean compareAndSetState(int expect, int update) {// See below for intrinsics setup to support thisreturn unsafe.compareAndSwapInt(this, stateOffset, expect, update);}

通过这段代码我们发现设置state 的状态使用的就是乐观锁，当前值是否与预期值相同，相同就设置成功。

在acquire 方法中，当获取锁失败时，我们知道一般会做持续获取锁，直到超时时间，才会返回获取锁失败，

那么看下本次获取锁失败后执行的方法是acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

方法，我们通过源码来看下，源码是如何操作的

    private Node addWaiter(Node mode) {Node node = new Node(Thread.currentThread(), mode);// Try the fast path of enq; backup to full enq on failureNode pred = tail;if (pred != null) {node.prev = pred;if (compareAndSetTail(pred, node)) {pred.next = node;return node;}}enq(node);return node;}  private Node enq(final Node node) {for (;;) {Node t = tail;if (t == null) { // Must initializeif (compareAndSetHead(new Node()))tail = head;} else {node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;}}}}  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 GCfailed = false;return interrupted;}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}}

通过源码我们可以看到

1. addWaiter：通过自旋CAS，将当前线程加入上面锁的双向链表（等待队列）中。
2. acquireQueued：通过自旋，判断当前队列节点是否可以获取锁。

参考文档

https://www.jianshu.com/p/7b0e11a1e605