public interface Lock {
    // 1
    void lock();
    // 2
    void lockInterruptibly() throws InterruptedException;
    // 3
    boolean tryLock();
    // 4
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
  
    void unlock();
    Condition newCondition();
}

/**
  * Base of synchronization control for this lock. Subclassed
  * into fair and nonfair versions below. Uses AQS state to
  * represent the number of holds on the lock.
  */
 static abstract class Sync extends AbstractQueuedSynchronizer

/**
 * Performs non-fair tryLock.  tryAcquire is
 * implemented in subclasses, but both need nonfair
 * try for trylock method.
 */
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    // 1
    int c = getState();
    // 2
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {// 3
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
        // 1
        int c = getState() - releases;
        // 2
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        boolean free = false;
        // 3
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
}

/**
 * Sync object for non-fair locks
 */
final static class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
     * Performs lock.  Try immediate barge, backing up to normal
     * acquire on failure.
     */
    final void lock() {
        // 1
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }
    
    // 2
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

/**
    * Sync object for fair locks
    */
   final static 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.
        */
        // 1
       protected final boolean tryAcquire(int acquires) {
           final Thread current = Thread.currentThread();
           int c = getState();
           // 2
           if (c == 0) {
               if (isFirst(current) &&
                   compareAndSetState(0, acquires)) {
                   setExclusiveOwnerThread(current);
                   return true;
               }
           }
           else if (current == getExclusiveOwnerThread()) {// 3
               int nextc = c + acquires;
               if (nextc < 0)
                   throw new Error("Maximum lock count exceeded");
               setState(nextc);
               return true;
           }
           return false;
       }
   }

/**
  * Creates an instance of {@code ReentrantLock}.
  * This is equivalent to using {@code ReentrantLock(false)}.
  */
 public ReentrantLock() {
     sync = new NonfairSync();
 }

 /**
  * Creates an instance of {@code ReentrantLock} with the
  * given fairness policy.
  *
  * @param fair {@code true} if this lock should use a fair ordering policy
  */
 public ReentrantLock(boolean fair) {
     sync = (fair)? new FairSync() : new NonfairSync();
 }

/**
    * Queries the number of holds on this lock by the current thread.
       ...
    */
   public int getHoldCount() {
       return sync.getHoldCount();
   }