ReentrantLock

1. 区分公平锁和非公平锁      默认非公平锁

            // 不公平的，是需要lock刚开始去抢锁一次
           final void lock() {
               if (compareAndSetState(0, 1))
                   setExclusiveOwnerThread(Thread.currentThread());
               else
                   acquire(1);
           }
   
           // 公平锁
           final void lock() {
               acquire(1);
           }

    

2.  不管公平锁还是不公平锁，都会进入方法acquire()

   public final void acquire(int arg) {
       if (!tryAcquire(arg) &&
           acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
   
           selfInterrupt();
   }

    

3. acquire第一步  tryAcquire     非公平锁当无锁时，会进行一次竞争锁，而公平锁是乖乖得去排队

           protected final boolean tryAcquire(int acquires) {   // 公平锁
               final Thread current = Thread.currentThread();
               int c = getState();
               if (c == 0) {
                   if (!hasQueuedPredecessors() &&
                       compareAndSetState(0, acquires)) {
                       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;
           }
   
   
            final boolean nonfairTryAcquire(int acquires) {     // 非公平锁
               final Thread current = Thread.currentThread();
               int c = getState();
               if (c == 0) {
                   if (compareAndSetState(0, acquires)) {
                       setExclusiveOwnerThread(current);
                       return true;
                   }
               }
               else if (current == getExclusiveOwnerThread()) {
                   int nextc = c + acquires;
                   if (nextc < 0) // overflow
                       throw new Error("Maximum lock count exceeded");
                   setState(nextc);
                   return true;
               }
               return false;
           }

    

4. tryAcquire方法失败  也就是返回false 则进入方法  addWaiter    作用就是加入等待队列

       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;
           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) {
           for (;;) {
               Node t = tail;
               if (t == null) { // Must initialize
                   if (compareAndSetHead(new Node()))
                       tail = head;
               } else {
                   node.prev = t;
                   if (compareAndSetTail(t, node)) {
                       t.next = node;
                       return t;
                   }
               }
           }
       }

    

5.  加入等待队列成功之后，则调用acquireQueue 方法 传入刚刚建的node节点；功能

       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;
                   }
                   if (shouldParkAfterFailedAcquire(p, node) &&
                       parkAndCheckInterrupt())
                       interrupted = true;
               }
           } finally {
               if (failed)
                   cancelAcquire(node);
           }
       }
   
   //循环中每次都会判断给定当前节点的先驱节点，如果没有先驱节点会直接抛出空指针异常，直到返回 true
   
   //如果不是头节点的情况下进入方法shouldParkAfterFailedAcquire   parkAndCheckInterrupt

    

6. shouldParkAfterFailedAcquire  parkAndCheckInterrupt方法如下

       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();
       }