public void lock() {sync.lock();}

    public ReentrantLock() {sync = new NonfairSync();}public ReentrantLock(boolean fair) {sync = (fair)? new FairSync() : new NonfairSync();}

 final void lock() {// 利用cas置状态位，如果成功，则表示占有锁成功if (compareAndSetState(0, 1))// 记录当前线程为锁拥有者
                setExclusiveOwnerThread(Thread.currentThread());elseacquire(1);}

    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();// 如果状态为0，则表示该锁未被其他线程占有if (c == 0) {// 此时要再次利用cas去尝试占有锁if (compareAndSetState(0, acquires)) {// 标记当前线程为锁拥有者
                    setExclusiveOwnerThread(current);return true;}}// 如果当前线程已经占有了，则state + 1,记录占有次数else if (current == getExclusiveOwnerThread()) {int nextc = c + acquires;if (nextc < 0) // overflowthrow new Error("Maximum lock count exceeded");// 此时无需利用cas去赋值，因为该锁肯定被当前线程占有
                setState(nextc);return true;}return false;}

  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) {// CAS方法有可能失败，因此要循环调用，直到当前线程的节点加入到队列中for (;;) {Node t = tail;if (t == null) { // Must initializeNode h = new Node(); // Dummy header，头节点为虚拟节点h.next = node;node.prev = h;if (compareAndSetHead(h)) {tail = node;  return h;}}else {node.prev = t;if (compareAndSetTail(t, node)) {t.next = node;return t;}}}}

 final boolean acquireQueued(final Node node, int arg) {try {boolean interrupted = false;for (;;) {// 获得前一个节点final Node p = node.predecessor();// 如果前一个节点是头结点，那么直接去尝试获得锁// 因为其他线程有可能随时会释放锁，没必要Park等待if (p == head && tryAcquire(arg)) {setHead(node);p.next = null; // help GCreturn interrupted;}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())interrupted = true;}} catch (RuntimeException ex) {cancelAcquire(node);throw ex;}}

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) {// 如果前面的节点是CANCELLED状态，则一直提前do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);pred.next = node;} else {compareAndSetWaitStatus(pred, ws, Node.SIGNAL);} return false;}private final boolean parkAndCheckInterrupt() {LockSupport.park(this);return Thread.interrupted();}public static void park(Object blocker) {Thread t = Thread.currentThread();setBlocker(t, blocker);unsafe.park(false, 0L);setBlocker(t, null);}

 public final boolean release(int arg) {// 释放锁if (tryRelease(arg)) {Node h = head;// 此处有个疑问，为什么需要判断h.waitStatus != 0if (h != null && h.waitStatus != 0)unparkSuccessor(h);return true;}return false;}protected final boolean tryRelease(int releases) {int c = getState() - releases;if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free = false;if (c == 0) {free = true;setExclusiveOwnerThread(null);}setState(c);return free;}