final void lock() {
  if (compareAndSetState(0, 1)) //直接修改state，失败才会进入到AQS的acquire逻辑中
        setExclusiveOwnerThread(Thread.currentThread()); //修改state成功代表当前没有线程持有锁，可以直接获取；
      //并且代表设置记录当前线程（之后重入做准备）
  else{
      acquire(1);
    }

   public final void acquire(int arg) {
       if (!tryAcquire(arg) &&   //teyAcquire在NonFair和Fair中有不同的逻辑。代表尝试获取锁
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)){ //addWaiter用来将当前线程封装为Node添加到AQS的阻塞队列中。之后acquireQueued是阻塞线程当线程唤醒并且拿到锁后检查阻塞过程中是否中断过，
         //如果发生过中断acquireQueue返回true，没有发生过中断返回false。selfInterrupt中进行补偿处理
        selfInterrupt()
 }

final boolean nonFairTryAcquire(int acquires) {
      final Thread current = Thread.currentThread();
       int c = getState();
        if (c == 0) {
          if (compareAndSetState(0, acquires)) {//如果没有线程拿着锁，直接尝试修改state
                setExclusiveOwnerThread(current);//修改成功代表获取锁成功，并且记录保存当前线程
             return true;
             }
          } else if (current == getExclusiveOwnerThread()) {//代表锁已经被线程拿着了，在判断是不是当前线程拿过如果拿过代表可以重入state加一。
            int nextc = c + acquires; //修改state+1 代表重入此时为state2
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                  setState(nextc);//设置state状态。
                  return true; //返回true代表获取锁成功
            }
             //代表被其他线程拿着锁返回false代表获取锁失败
            return false;
}

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
    if (!hasQueuedPredecessors() &&
         compareAndSetState(0, acquires)) {  //这个条件要比NonFair更加严格，如果没有线程拿着锁，还要判断当前线程是不是在AQS的阻塞队列头部。如果在队列头部才可以进行修改state值，否则不能修改。注意：这也是公平锁和非公平锁的不同
          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;
}

/**
     * Creates and enqueues node for current thread and given mode. *
     * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
     * @return the new node
      */
        //将当前线程封装为Node不断使用cas来将tail节点指向当前Node。也就是入队操作
 private Node addWaiter(Node mode) {
     Node node = new Node(mode);
       for (;;) {
           Node oldTail = tail;
           if (oldTail != null) {
               U.putObject(node, Node.PREV, oldTail);
              if (compareAndSetTail(oldTail, node)) {
                      oldTail.next = node;
                       return node;
                  }
           } else {
             initializeSyncQueue();
           }
      }
}
/**
 * Initializes head and tail fields on first contention.
  */初始化尾结点tail
private final void initializeSyncQueue() {
   Node h;
  if (U.compareAndSwapObject(this, HEAD, null, (h = new Node())))
      tail = h;
}
/**
* CASes tail field.
*///不断设置尾结点tail指向当前Node
 private final boolean compareAndSetTail(Node expect, Node update) {
  return U.compareAndSwapObject(this, TAIL, expect, update);
}

//上一步addWaiter代表添加到阻塞队列中，这一步该阻塞线程了。
  final boolean acquireQueued(final Node node, int arg) {
        try {
        //              中断标志位由于acquire在阻塞过程中是不会立即响应interrupt的，所以需要标识记录。当线程获取到锁的时候在进行补偿处理
          boolean interrupted = false;
        //              死循环目的：由于park是会被interrupt唤醒的，所以需要检查如果不是unPark唤醒的需要继续阻塞。
            for (;;) {
        //                取出前一个节点观察是不是头结点（由于Head指向的是一个空节点Node。所以前一个节点是Head就代表当前Node就是第一个要出队的Node），如果是头结点代表可以进行获取锁的逻辑。
       final Node p = node.predecessor();
             if (p == head && tryAcquire(arg)) {//当前位于AQS阻塞队列头部，并且获取锁成功（tryAcquire上面讲解过）。设置当前为头结点接着返回中断标志位进行补偿处理中断操作
                    setHead(node);
                    p.next = null; // help GC
                     return interrupted;
                }
        //                  //如果当前节点不是头部，
                 if (shouldParkAfterFailedAcquire(p, node) &&
                           parkAndCheckInterrupt())  //阻塞自己
                      interrupted = true; //如果满足这个条件代表是interrupt唤醒的，需要记录标志位。接着再次进入到死循环中
                   }
             } catch (Throwable t) {
                   cancelAcquire(node);
                    throw t;
              }
  }
  private final boolean parkAndCheckInterrupt() {
      LockSupport.park(this);  //park自己阻塞自己，park只有两种情况会被唤醒   第一种由于unPark如果是被这种方式唤醒的那么就该进入到获取锁的逻辑中；还有一种情况是由于interrupt导致的唤醒这种情况下根据是否立即响应还是拿到锁之后再响应分为两种方法  acquire和acquireInterruptibly
      return Thread.interrupted();
   }

public final boolean release(int arg) {
     if (tryRelease(arg)) {  //尝试释放锁，注意：只有已经持有锁的线程才可以进行释放锁；没有持有锁的话释放没用..。该条件成立代表该线程已经不在持有锁了所以需要唤醒其他线程
          Node h = head;  取出头结点
          if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);  //准备唤醒处于AQS阻塞队列中的头结点
               return true;
        }
            return false;
  }

protected final boolean tryRelease(int releases) {
        int c = getState() - releases;  //调用一次unlock也就是调用一次Sync的release也就是进行一次锁的递减。因此同一个lock重入多少次就要unlock多少次
        if (Thread.currentThread() != getExclusiveOwnerThread())
             throw new IllegalMonitorStateException();
          boolean free = false;
           if (c == 0) {
                 //当前线程不再持有锁，需要唤醒阻塞队列中的阻塞线程设置free代表该现场已经不在持有锁了，然后清空拥有锁的线程标志位
              free = true;
              setExclusiveOwnerThread(null);
          }
          setState(c);//由于只有持有锁的线程才可以进行tryRelease，又因为是排它锁，所以这里面是线程安全的。
         return free;  //返回free、只有当没有重入state等于0才可以返回true也才可以进行唤醒其他线程。如果一个线程重入了两次，只调用了一次unlock那么是不会唤醒其他线程的
}

private void unparkSuccessor(Node node) {
    int ws = node.waitStatus;
        if (ws < 0)
             node.compareAndSetWaitStatus(ws, 0);
            /*
             * Thread to unpark is held in successor, which is normally
             * just the next node.  But if cancelled or apparently null,
          * traverse backwards from tail to find the actual
           * non-cancelled successor.
             */
            Node s = node.next;
          if (s == null || s.waitStatus > 0) {
              s = null;
               for (Node p = tail; p != node && p != null; p = p.prev)
                  if (p.waitStatus <= 0)
                       s = p;
            }
             if (s != null)
                  LockSupport.unpark(s.thread);  //唤醒线程
 }