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

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

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