//是ReentrantLock的核心，同时也是其他同步工具CountDownLatch,Semaphore等的核心，有兴趣的朋友在看完这篇文章后,可以自己手动去分析下CountDownLatch，Semaphore的实现
abstract static class Sync extends AbstractQueuedSynchronizer {}
可以看到ReentrantLock的lock方法直接调用了内部成员变量sync的lock方法,这里我们直接分析非公平的实现NonfairSync的实现。
2.AbstractQueuedSynchronizer#compareAndSetState()
//compareAndSetState方法直接调用Unsafe类compareAndSwapInt的方法,保证原子性的替换state的值
protected final boolean compareAndSetState(int expect, int update) {
return U.compareAndSwapInt(this, STATE, expect, update);
}
3.AbstractQueuedSynchronizer#acquire()
public final void acquire(int arg) {
//直接调用tryAcquire去尝试获取锁
//如果尝试获取锁不成功调用acquireQueued
//selfInterrupt挂起当前线程
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
4.NonfairSync#tryAcquire()
protected final boolean tryAcquire(int acquires) {
//直接调用父类Sync的nonfairTryAcquire方法
return nonfairTryAcquire(acquires);
}
5.Sync#nonfairTryAcquire()
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
//如果AbstractQueuedSynchronizer的stateE等于0
//代表当前没有线程占有临界资源
//直接调用compareAndSetState，如果CAS成功就把当前线程设置为独占线程
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//如果state不为0,判断占有临界资源的线程是否和当前获取锁的线程是一个线程，如果是调用setState重置当前state的值，这里我们可以看出来，ReentrantLock它是可重入的锁和synchronized一样
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error(“Maximum lock count exceeded”);
setState(nextc);
return true;
}
//尝试获取锁还是失败的话
//回到AbstractQueuedSynchronizer的addWaiter方法
return false;
}
6.AbstractQueuedSynchronizer#addWaiter()
private Node addWaiter(Node mode) {
//节点类型有两种
//SHARED共享模式 EXCLUSIVE独占模式
//新建一个独占节点
Node node = new Node(mode);
//这里通过自旋和CAS的方
法将当前节点添加的队列的尾部
//AbstractQueuedSynchronizer内部有两个成员变量head和tail,这里其实就是双向链表实现的一个双端队列。head 和 tail 分别指向双端队列的头尾节点。
for (;