final boolean nonfairTryAcquire(int acquires) {   //acquires=1
    final Thread current = Thread.currentThread();   
    int c = getState();   
    if (c == 0) {   //发现没有线程占用锁
        if (compareAndSetState(0, acquires)) {   
            setExclusiveOwnerThread(current);   
            return true;   
        }   
    }   
    else if (current == getExclusiveOwnerThread()) {   //发现当前占用锁的是自己 则对应的计数器加1 修改对应的state 这里体现了偏向锁
        int nextc = c + acquires;   
        if (nextc < 0) // overflow   
            throw new Error("Maximum lock count exceeded");   
        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 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   
            Node 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();   
            if (p == head && tryAcquire(arg)) {    //
                setHead(node);   
                p.next = null; // help GC   
                return interrupted;    // if执行满足 也就是 头队列的线程获得了锁 则执行 if 中的 内容 renturn 退出整个的 for 循环
            }   
            if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())   //在此阻塞
                interrupted = true;   
        }   
    } catch (RuntimeException ex) {   
        cancelAcquire(node);   
        throw ex;   
    }   
}   

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

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

class AbstractQueuedSynchronizer

public final boolean release(int arg) {   
    if (tryRelease(arg)) {   
        Node h = head;   
        if (h != null && h.waitStatus != 0)   
            unparkSuccessor(h);   
        return true;   
    }   
    return false;   
}   
class Sync

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

private void unparkSuccessor(Node node) {   
    /*  
     * If status is negative (i.e., possibly needing signal) try  
     * to clear in anticipation of signalling. It is OK if this  
     * fails or if status is changed by waiting thread.  
     */   
    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.  
     */   
    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;   
    }   
    if (s != null)   
        LockSupport.unpark(s.thread);   
}