public void test() throw Exception {
    
    // 默认非公平锁 sync = new NonfairSync()
    ReentrantLock lock = new ReentrantLock(); 
    lock.lock();
    try {
        xxxx
        // 嵌套 重入
        lock.lock();
        try {
            yyyy
        } finally {
            lock.unlock()                
        }
    } finally {
     	lock.unlock()
    }
}

// 核心API
public interface Lock {

	// 拼尽全力的获取锁
    // 尝试获取锁 -- 失败，disable scheduling && lie dormant直到获取锁; 
    void lock();
    
   	// 浅尝辄止的获取锁
    // 尝试获取锁，如果当前锁可以获取，则获取；反之直接返回，这个try表达了试一下就算了
    boolean tryLock();
    
    // 较上面的，增加了获取超时时长
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    
    // 尝试获取锁 -- 失败，disable scheduling && lie dormant -- 直到该线程被其它中断(interuptted) 或者是 该线程获取锁
    void lockInterruptibly() throws InterruptedException;
    
    
    // 与加锁相对应，释放锁
    void unlock();
    
    // 条件队列
    Condition newCondition();
    
}

public abstract class AbstractQueuedSynchronizer {
    
    static final class Node {
        
        // 当前节点的等待状态，因为本质上来讲这些入队的线程都是入队以在将来获取执行时间的
        
        /*
        	0: 初始化状态
            SIGNAL: 代表后继结点需要被唤醒, 该状态表示的是后继结点的状态而不是本结点状态
        	CANCELLED: 线程获取锁的请求取消
        	PROPAGATE: 当线程处于SHARD情况下, 该字段才会使用
        	CONDITION: 表示结点再同步队列中，节点线程等待唤醒
        */
        
        volatile int waitStatus;
        
        // 当前入队线程的前驱
        volatile Node prev;
        
        // 当前入队线程的后继
        volatile Node next;
        
        // 当前入队的线程
        volatile Thread thread;
        
        // 指向下一个等待condition的线程
        Node nextWaiter;
        
    }
    
    // 同步队列的头部
    private transient volatile Node head;
       
    // 同步队列的尾部
    private transient volatile Node tail;
    
     /**
     * The synchronization state -- AQS和共享资源一一对应
     */
    private volatile int state;
    
    
    // 条件队列
    public class ConditionObject implements Condition, java.io.Serializable {
        
    }

}

// 加锁操作
while (synchronization state does not allow acquire) {
	enqueue current thread if not already queued;
	possibly block currrent thread and waited to be signaled
}
dequeue current thread if it is queued and acquire again

// 释放锁流程
update synchronization state;
if (state may permit a blocked thread to accquire)
  unblock one or more queued threads;

static final class FairSync extends Sync {
    
    // 检查队列中是否已经有线程再排队，没有才进行CAS操作
    protected final boolean tryAcquire(int acquires) {
        ...
        if (
            !hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)
        ) {
            setExclusiveOwnerThread(current);
            return true;
        }
        ...
    }
    
}

abstract static class Sync extends AbstractQueuedSynchronizer { 
	...
    final boolean nonfairTryAcquire(int acquires) {
        ...
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
        ...
    }
	...
}

// 方法主要目的：node 追加到同步队列的队尾
// 入参 mode 表示Node的模式（排它模式还是共享模式)
// 出参是新增的 node

// 主要思路：
// 新 node.pre = 队尾
// 队尾.next = 新 node
private Node addWaiter(Node mode) {
    // 初始化 Node
    Node node = new Node(Thread.currentThread(), mode);
  
    // 这里的逻辑和enq一致，enq的逻辑仅仅多了队尾是空，初始化的逻辑
    // 这个思路在java源码中很常见，先简单的尝试放一下，成功立马返回，如果不行，再 while循环
    // 很多时候，这种算法可以帮忙解决大部分的问题，大部分的入队可能一次都能成功，无需自旋
    
    // 在ReplicaManager内部进行其它副本测试的，也算是假如延时任务体系时候会先再检查一下
    Node pred = tail;
    if (pred != null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //自旋保证node加入到队尾
    enq(node);
    return node;
}

// 线程加入同步队列中方法，追加到队尾
// 这里需要重点注意的是，返回值是添加 node 的前一个节点
private Node enq(final Node node) {
    for (;;) {
        // 得到队尾节点
        Node t = tail;
        // 如果队尾为空，说明当前同步队列都没有初始化，进行初始化
        // tail = head = new Node();
        if (t == null) {
            if (compareAndSetHead(new Node()))
                tail = head;
        // 队尾不为空，将当前节点追加到队尾
        } else {
            node.prev = t;
            // node 追加到队尾
            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 GC
                failed = false;
                return interrupted;
            }
            
            // 尝试获取锁失败之后，是否需要被挂起(即设置前驱waitStatus == SIGNAL)
            if (
                shouldParkAfterFailedAcquire(p, node) &&
                
                // 这个地方是线程挂起的地方，后续有线程释放锁，会唤醒该线程然后继续自旋加锁
                // LockSupport.park()
                parkAndCheckInterrupt()
            )
            interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
    
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    if (ws == Node.SIGNAL)
        /*
        * This node has already set status asking a release
        * to signal it, so it can safely park.
        */
        return true;
    
    if (ws > 0) {
        /*
             Predecessor was cancelled. Skip over predecessors and
             indicate retry.
             
             前驱被放弃获取锁，所以需要将其剔除
		   */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);

        pred.next = node;
    } else {
        /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

private final boolean parkAndCheckInterrupt() {
  	LockSupport.park(this);
    return Thread.interrupted();
}

// java.util.concurrent.locks.AbstractQueuedSynchronizer
private void cancelAcquire(Node node) {
  // 将无效节点过滤
	if (node == null)
		return;

  // 设置该节点不关联任何线程，也就是虚节点
	node.thread = null;
	Node pred = node.prev;

   // 通过前驱节点，跳过取消状态的node
	while (pred.waitStatus > 0)
		node.prev = pred = pred.prev;
    
  // 获取过滤后的前驱节点的后继节点
	Node predNext = pred.next;
  // 把当前node的状态设置为CANCELLED
	node.waitStatus = Node.CANCELLED;
  // 如果当前节点是尾节点，将从后往前的第一个非取消状态的节点设置为尾节点
  // 更新失败的话，则进入else，如果更新成功，将tail的后继节点设置为null
	if (node == tail && compareAndSetTail(node, pred)) {
		compareAndSetNext(pred, predNext, null);
	} else {
		int ws;
    // 如果当前节点不是head的后继节点，1:判断当前节点前驱节点的是否为SIGNAL，2:如果不是，则把前驱节点设置为SINGAL看是否成功
    // 如果1和2中有一个为true，再判断前驱的线程是否为null
    // 如果上述条件都满足，把当前节点的前驱节点的后继指针指向当前节点的后继节点

        if (
            pred != head && 
           ((ws = pred.waitStatus) == Node.SIGNAL || (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) 
            && pred.thread != null
        ) {
			Node next = node.next;
			if (next != null && next.waitStatus <= 0)
				compareAndSetNext(pred, predNext, next);
		} else {
      		// 如果当前节点是head的后继节点，或者上述条件不满足，那就唤醒当前节点的后继节点
    		// 因为当前线程获取锁失败了，所以尝试唤醒下一个排队的。
            // 就像竞标买房，上一个出价的人失败后(设置cancel状态)，轮到下一个人出价
			unparkSuccessor(node);
		}
		node.next = node; // help GC
	}
}

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

// java.util.concurrent.locks.AbstractQueuedSynchronizer
public final boolean release(int arg) {
  
    // 上边自定义的tryRelease如果返回true，说明该锁没有被任何线程持有
    if (tryRelease(arg)) {
        // 获取头结点 为null说明没有线程排队
        Node h = head;
        // 头结点不为空并且头结点的waitStatus不是初始化节点情况，解除线程挂起状态
        if (h != null && h.waitStatus != 0) {
            unparkSuccessor(h);
        }
        return true;
    }
  
    return false;
}

public boolean tryRelease(int arg) {
    int c = getState()
    int state = c - arg;
    boolean free = false;
	  if (state == 0) {
        // 变为0, 成功释放锁，同时设置Owner线程为null
        setExclusiveOwnerThread(null);
        free = true;
    }
    setState(state); 
    return free;
}

private void unparkSuccessor(Node node) { 
	Node s = node.next;
    
    // 后继结点为null 或者 已经放弃获取锁; 则尝试从尾到头再挑选一个Node进行唤醒; 最终返回的离node最近的 需要唤醒的
    // s.waitStatus 大于0，代表 s 节点已经被取消了
    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);   
    }
    
}

// ConsumerNetworkClient

// We do not need high throughput, so use a fair lock to try to avoid starvation;
// 公平锁避免 starvation; 从这句话可以看出，非公平锁的吞吐量会更高 
private final ReentrantLock lock = new ReentrantLock(true);

public void poll(Timer timer, PollCondition pollCondition, boolean disableWakeup) {
    
    try {
	    lock.lock();
    } finally {
    	lock.unlock();
	}

}

public final void acquireInterruptibly(int arg) throws InterruptedException {
    if (Thread.interrupted()) {
        throw new InterruptedException();
    }
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg);    
    
    }
}

private void doAcquireInterruptibly(int arg) {
    
    if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) {
        throw new InterruptedException();
    }
                    
}

else if (current == getExclusiveOwnerThread()) {
    int nextc = c + acquires;
    
    // ! 自己已经获取过锁了，当然可以安全的进行修改
    setState(nextc);
	return true;
}