static final class Node {
           // 标记Node为共享模式 
           static final Node SHARED = new Node();
           // 标记Node为独占模式
           static final Node EXCLUSIVE = null;
   
           // waitStatus 的几种状态
           // 当前Node因为超时或中断被取消，进入该状态的节点不会再一次被阻塞
           static final int CANCELLED =  1;
           // node进入队列后 要确保前一个节点为SIGNAL 前一个节点释放的时候需要unpark进入队列的这个节点
           static final int SIGNAL    = -1;
           // 
           static final int CONDITION = -2;
           static final int PROPAGATE = -3;
           // 还有 默认0 无状态
   
         
           volatile int waitStatus;
   
           // 双向队列 指向前一个个Node
           volatile Node prev;
           // 双向队列 指向后一个Nodesss
           volatile Node next;
           // 当前等待线程 ！！ Node的心脏
           volatile Thread thread;
   
           //  指向下一个在同一个condition里等待的node
           // 或者一个特殊的值：SHARED
           //conditions队列仅仅只能是独占模式  如果是共享模式 我们会用一个特殊的值标记SHARED
           Node nextWaiter;
   
           // 是否是共享模式 
           final boolean isShared() {
               return nextWaiter == SHARED;
           }
   
           // 返回前一个Node
           final Node predecessor() throws NullPointerException {
               Node p = prev;
               if (p == null)
                   throw new NullPointerException();
               else
                   return p;
           }
   		// 初始化head 和 共享标记的时候用
           Node() {  
           }
   		// addWaiter用
           Node(Thread thread, Node mode) {    
               this.nextWaiter = mode;
               this.thread = thread;
           }
   		// Condition 用 
           Node(Thread thread, int waitStatus) {
               this.waitStatus = waitStatus;
               this.thread = thread;
           }
       }

  /**
        * Attempts to acquire in exclusive mode. This method should query
        * if the state of the object permits it to be acquired in the
        * exclusive mode, and if so to acquire it.
        * 尝试以独占锁模式去获取，他会查询state状态，如果允许他以独占锁模式获取 那就获取 
        * <p>This method is always invoked by the thread performing
        * acquire.  If this method reports failure, the acquire method
        * may queue the thread, if it is not already queued, until it is
        * signalled by a release from some other thread. This can be used
        * to implement method {@link Lock#tryLock()}.
        * 如果获取失败，会把当前线程放到队列里 直到这个线程被其他释放线程唤醒 
        * 也就是说你排队呢 拿着手机看抖音小媚媚  前边的人结账完了 回头叫你一声 
        * 嘿！别看了 结账了 
        * <p>The default
        * implementation throws {@link UnsupportedOperationException}.
        *
        * @param arg the acquire argument.
        * 这个值一般情况下都是1 
        * 
        * @return {@code true} if successful. Upon success, this object has
        *         been acquired.
        * 如果获取成功  返回true  
        */
       protected boolean tryAcquire(int arg) {
           throw new UnsupportedOperationException();
       }

 /**
        * Sync object for fair locks
        */
       static final class FairSync extends Sync {
           private static final long serialVersionUID = -3000897897090466540L;
   		//锁方法  
           final void lock() {
               acquire(1);
           }
   
           /**
            * Fair version of tryAcquire.  Don't grant access unless
            * recursive call or no waiters or is first.
            * tryAcquire的公平版，只有是递归调用或者是waiters或者是first的是会后才给获取权限
            * 没有很懂：理解就是满足一定条件（公平）才可以获取锁
            */
           protected final boolean tryAcquire(int acquires) {
               // 获取当前线程
               final Thread current = Thread.currentThread();
               // 获取状态 这个就是两个核心中的一个 : 状态位state
               // 这个直接调用的父类 AQS的getState()方法 
               // 继承的好处： 就是爸爸有的你也有 
               int c = getState();
               // 如果是0 那就是木有人占有 这时候准备修改状态 
               if (c == 0) {
                   // 1.hasQueuedPredecessors：  判断是否有其他线程比当前线程等待时间长 
                   // 2.compareAndSetState ： CAS 线程安全的 设置state状态 0->acquires 
                   // 
                   if (!hasQueuedPredecessors() &&
                       compareAndSetState(0, acquires)) {
                       // 设置独占线程为当前线程
                       setExclusiveOwnerThread(current);
                       return true;
                   }
               }
               // 如果state不等于0 看一下占用state的是不是当前线程
               else if (current == getExclusiveOwnerThread()) {
                   // 如果当前线程占用state 那就是重入了 state总数就+acquires
                   int nextc = c + acquires;
                   if (nextc < 0)
                       throw new Error("Maximum lock count exceeded");
                   setState(nextc);
                   return true;
               }
               // 如果没有获取 就返回false 
               return false;
           }
       }

   /**        * Acquires in exclusive mode, ignoring interrupts.         *  申请独占锁，忽略中断        * Implemented  by invoking at least once {@link #tryAcquire},        * returning on success.         * Otherwise the thread is queued, possibly        * repeatedly blocking and unblocking, invoking {@link        * #tryAcquire} until success.         * 至少调用一次tryAcquire ，如果成功就得了，不成功就把当前线程放到等待队列里         * 核心2：双向等待队列出现了        */       public final void acquire(int arg) {           // tryAcquire 看2例子           // addWaiter(独占方式加入队列) AQS 方法            // acquireQueued 这是一个死循环动作， 直到获取锁 也就是买到烧饼           if (!tryAcquire(arg) &&               acquireQueued(addWaiter(Node.EXCLUSIVE), arg))               selfInterrupt();       }

   	/**        * Creates and enqueues node for current thread and given mode.        * 你排队了，需要把你包装一下 因为你不再是你，你成了队伍中的一员        * 现实中可能会给你一个号码 或者给你一个宣传单 或者先给你点儿小吃吃着         * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared        * @return the new node        */       private Node addWaiter(Node mode) {           // 包装           Node node = new Node(Thread.currentThread(), mode);           // Try the fast path of enq; backup to full enq on failure           // 获取队列尾部元素            Node pred = tail;            // 如果尾部元素不是null 那就追加             // 下边这个过程 就是队列尾部cas方式追加新元素 tail指向新元素            if (pred != null) {X               // 当前插入的node的前一个node设置为tail                node.prev = pred;               // cas把tail设置为刚添加的元素                if (compareAndSetTail(pred, node)) {                   // 老tail 的下一个元素 指向新node                    pred.next = node;                   return node;               }           }           // 如果是null 那就一般情况下是需要初始化队列             enq(node);           return node;       }      	/**        * Inserts node into queue, initializing if necessary        * 插入node到队列，如果有必要，会进行队列初始化        * @param node the node to insert        * @return node's predecessor        */       private Node enq(final Node node) {           // 死等 直到成功为止           for (;;) {               Node t = tail;               // 如果是null 初始化                if (t == null) {                   // 设置一个新Node为head 并且tail也指向这个node                    if (compareAndSetHead(new Node()))                       tail = head;               } else {                   // 设置node上一个元素为t（刚添加的空node）                   node.prev = t;                   // cas设置tail为node (来排队的人)                   if (compareAndSetTail(t, node)) {                       t.next = node;                       return t;                   }               }           }       }

        /**        * Acquires in exclusive uninterruptible mode for thread already in        * queue. Used by condition wait methods as well as acquire.        * 在queue中的线程以独占并且不中断模式申请锁        * @param node the node        * @param arg the acquire argument        * @return {@code true} if interrupted while waiting        */       final boolean acquireQueued(final Node node, int arg) {           boolean failed = true;           try {               // 中断设置为false                boolean interrupted = false;               for (;;) {                   //获取当前Node的前一个Node                    final Node p = node.predecessor();                   // 如果前一个Node是head，该小强买了 来1个烧饼                   if (p == head && tryAcquire(arg)) {                       // 设置小强为head 这样他的下一个人就知道可以轮到他了                       setHead(node);                       // 加快gc                       p.next = null; // help GC                       failed = false;                       return interrupted;                   }                   // 如果没有获取 接着来                    //1. shouldParkAfterFailedAcquire 检查状态  如果状态合适就park                   //2. parkAndCheckInterrupt 稍等片刻                   //3. 等着被unpark吧 坐等前边人买完了叫你                    if (shouldParkAfterFailedAcquire(p, node) &&                       parkAndCheckInterrupt())                       interrupted = true;               }           } finally {               // 失败 因为某种异常结束了 但是没有获取成功                // 取消获取锁的这个资格                // 比如小月月肚子疼 那就让他走吧 没资格吃烧饼了               // 这个方法就不看了 主要就是吧小月月的前一个人的next 设置为 小月月的后一个人               // 然后把小月月的后一个人的prev设置为小月月的前一个人                // 类比：链表的删除操作                if (failed)                   cancelAcquire(node);           }       }             /**        * Checks and updates status for a node that failed to acquire.        * 检查并设置获取锁失败的node的状态          * Returns true if thread should block. This is the main signal        * 如果node需要阻塞 返回true         * control in all acquire loops.  Requires that pred == node.prev.        *         * @param pred  前一个节点        * @param node  当前加入的节点        * @return {@code true} 如果可以阻塞 返回true         */       private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {           int ws = pred.waitStatus;           //            if (ws == Node.SIGNAL)               // SIGNAL 状态  可安全park                return true;           if (ws > 0) {               /*                * Predecessor was cancelled. Skip over predecessors and                * indicate retry.                * 状态大于0 那就是被取消了 需要往前找一个合法的node                * 也就是下月月肚子疼要走了，需要让他前边的那个人的后一个人变成小月月后边的那个人                * 类似于删除链表节点                */               do {                   node.prev = pred = pred.prev;               } while (pred.waitStatus > 0);               // 将合法的node的next设置为当前node                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.                */               // 设置状态为 为SIGNAL                compareAndSetWaitStatus(pred, ws, Node.SIGNAL);           }           return false;       }            /**        * Convenience method to park and then check if interrupted        * PARK 并检查是否是终端          * @return {@code true} if interrupted        */       private final boolean parkAndCheckInterrupt() {           // park 也是阻塞的一种 类比wait             LockSupport.park(this);           // 需要看一下  park过程中有没有被中断           return Thread.interrupted();       }

      /**   	* Releases in exclusive mode.  Implemented by unblocking one or        * more threads if {@link #tryRelease} returns true.        * This method can be used to implement method {@link Lock#unlock}.        *        * @param arg the release argument.  This value is conveyed to        *        {@link #tryRelease} but is otherwise uninterpreted and        *        can represent anything you like.        * @return the value returned from {@link #tryRelease}        */   public final boolean release(int arg) {       if (tryRelease(arg)) {           Node h = head;           // 如果head不为空 并且waitStatus不是0 需要通知下一个Node           // 买完了 告诉后边那个看抖音的人 该他买了           if (h != null && h.waitStatus != 0)               unparkSuccessor(h);           return true;       }       return false;   }      protected final boolean tryRelease(int releases) {        // state-需要释放的数量        int c = getState() - releases;        // 如果占有线程不是当前线程  抛异常          if (Thread.currentThread() != getExclusiveOwnerThread())            throw new IllegalMonitorStateException();        //         boolean free = false;        // 如果c ==0 也就是释放完了 lock lock release release         if (c == 0) {            free = true;            // 设置占有线程为null             setExclusiveOwnerThread(null);        }        // 设置状态位 == 0         setState(c);        return free;    }       /**        * Wakes up node's successor, if one exists.        * 如果存在下一个Node的话 唤醒它           * @param node the node        */       private void unparkSuccessor(Node node) {                    // 先设置当前Node状态 为0  也就是说拜拜了            int ws = node.waitStatus;           if (ws < 0)               compareAndSetWaitStatus(node, 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.            */           // 循环找一个合法的next             // 小强买完了看看后那个人是不是合法 万一他是小月月，正闹肚子呢 已经取消了cancelled            // 那肯定不唤醒他 让他拉粑粑去吧  接着看下月月的下一个是否合法 直到找见一个合法的 叫他来买饼           Node s = node.next;           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;           }           // 唤醒 unpark            if (s != null)               LockSupport.unpark(s.thread);       }