/* Lock接口 */
public interface Lock {
   
    // 拿不到锁就一直等，拿到马上返回。
    void lock(); 

    // 拿不到锁就一直等，如果等待时收到中断请求，则需要处理InterruptedException。
    void lockInterruptibly() throws InterruptedException; 

    // 无论拿不拿得到锁，都马上返回。拿到返回true，拿不到返回false。
    boolean tryLock(); 

    // 同上，可以自定义等待的时间。
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException; 

    void unlock();

    Condition newCondition();
}

class CachedData {
    Object data;
    volatile boolean cacheValid;
    final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

    void processCachedData() {
        rwl.readLock().lock();
        if (!cacheValid) {
            // Must release read lock before acquiring write lock
            rwl.readLock().unlock();
            rwl.writeLock().lock();
            try {
                // Recheck state because another thread might have
                // acquired write lock and changed state before we did.
                if (!cacheValid) {
                    data = ...
                    cacheValid = true;
                }
                // Downgrade by acquiring read lock before releasing write lock
                rwl.readLock().lock();
            } finally {
                rwl.writeLock().unlock(); // Unlock write, still hold read
            }
        }

        try {
            use(data);
        } finally {
            rwl.readLock().unlock();
        }
    }
}

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

class RWDictionary {
    private final Map<String, Data> m = new TreeMap<String, Data>();
    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private final Lock r = rwl.readLock();
    private final Lock w = rwl.writeLock();

    public Data get(String key) {
        r.lock();
        try {
            return m.get(key);
        } finally {
            r.unlock();
        }
    }

    public String[] allKeys() {
        r.lock();
        try {
            return m.keySet().toArray();
        } finally {
            r.unlock();
        }
    }

    public Data put(String key, Data value) {
        w.lock();
        try {
            return m.put(key, value);
        } finally {
            w.unlock();
        }
    }

    public void clear() {
        w.lock();
        try {
            m.clear();
        } finally {
            w.unlock();
        }
    }
}

/** Inner class providing readlock */
private final ReentrantReadWriteLock.ReadLock readerLock;
/** Inner class providing writelock */
private final ReentrantReadWriteLock.WriteLock writerLock;
/** Performs all synchronization mechanics */
final Sync sync;

/**
 * Creates a new {@code ReentrantReadWriteLock} with
 * default (nonfair) ordering properties.
 */
public ReentrantReadWriteLock() {
    this(false);
}

/**
 * Creates a new {@code ReentrantReadWriteLock} with
 * the given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantReadWriteLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
    readerLock = new ReadLock(this);
    writerLock = new WriteLock(this);
}

public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }

/**
 * Synchronization implementation for ReentrantReadWriteLock.
 * Subclassed into fair and nonfair versions.
 */
abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 6317671515068378041L;

    /*
     * Read vs write count extraction constants and functions.
     * Lock state is logically divided into two unsigned shorts:
     * The lower one representing the exclusive (writer) lock hold count,
     * and the upper the shared (reader) hold count.
     */

    static final int SHARED_SHIFT   = 16;
    static final int SHARED_UNIT    = (1 << SHARED_SHIFT);
    static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;
    static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;

    /** Returns the number of shared holds represented in count  */
    static int sharedCount(int c)    { return c >>> SHARED_SHIFT; }
    /** Returns the number of exclusive holds represented in count  */
    static int exclusiveCount(int c) { return c & EXCLUSIVE_MASK; }

    /**
     * A counter for per-thread read hold counts.
     * Maintained as a ThreadLocal; cached in cachedHoldCounter
     */
    static final class HoldCounter {
        int count = 0;
        // Use id, not reference, to avoid garbage retention
        final long tid = getThreadId(Thread.currentThread());
    }

    /**
     * ThreadLocal subclass. Easiest to explicitly define for sake
     * of deserialization mechanics.
     */
    static final class ThreadLocalHoldCounter
        extends ThreadLocal<HoldCounter> {
        public HoldCounter initialValue() {
            return new HoldCounter();
        }
    }

    /**
     * The number of reentrant read locks held by current thread.
     * Initialized only in constructor and readObject.
     * Removed whenever a thread's read hold count drops to 0.
     */
    private transient ThreadLocalHoldCounter readHolds;

    /**
     * The hold count of the last thread to successfully acquire
     * readLock. This saves ThreadLocal lookup in the common case
     * where the next thread to release is the last one to
     * acquire. This is non-volatile since it is just used
     * as a heuristic, and would be great for threads to cache.
     *
     * <p>Can outlive the Thread for which it is caching the read
     * hold count, but avoids garbage retention by not retaining a
     * reference to the Thread.
     *
     * <p>Accessed via a benign data race; relies on the memory
     * model's final field and out-of-thin-air guarantees.
     */
    private transient HoldCounter cachedHoldCounter;

    /**
     * firstReader is the first thread to have acquired the read lock.
     * firstReaderHoldCount is firstReader's hold count.
     *
     * <p>More precisely, firstReader is the unique thread that last
     * changed the shared count from 0 to 1, and has not released the
     * read lock since then; null if there is no such thread.
     *
     * <p>Cannot cause garbage retention unless the thread terminated
     * without relinquishing its read locks, since tryReleaseShared
     * sets it to null.
     *
     * <p>Accessed via a benign data race; relies on the memory
     * model's out-of-thin-air guarantees for references.
     *
     * <p>This allows tracking of read holds for uncontended read
     * locks to be very cheap.
     */
    private transient Thread firstReader = null;
    private transient int firstReaderHoldCount;

    Sync() {
        readHolds = new ThreadLocalHoldCounter();
        setState(getState()); // ensures visibility of readHolds
    }

    /*
     * Acquires and releases use the same code for fair and
     * nonfair locks, but differ in whether/how they allow barging
     * when queues are non-empty.
     */

    /**
     * Returns true if the current thread, when trying to acquire
     * the read lock, and otherwise eligible to do so, should block
     * because of policy for overtaking other waiting threads.
     */
    abstract boolean readerShouldBlock();

    /**
     * Returns true if the current thread, when trying to acquire
     * the write lock, and otherwise eligible to do so, should block
     * because of policy for overtaking other waiting threads.
     */
    abstract boolean writerShouldBlock();

    /*
     * Note that tryRelease and tryAcquire can be called by
     * Conditions. So it is possible that their arguments contain
     * both read and write holds that are all released during a
     * condition wait and re-established in tryAcquire.
     */

    protected final boolean tryRelease(int releases) {
        if (!isHeldExclusively())
            throw new IllegalMonitorStateException();
        int nextc = getState() - releases;
        boolean free = exclusiveCount(nextc) == 0;
        if (free)
            setExclusiveOwnerThread(null);
        setState(nextc);
        return free;
    }

    protected final boolean tryAcquire(int acquires) {
        /*
         * Walkthrough:
         * 1. If read count nonzero or write count nonzero
         *    and owner is a different thread, fail.
         * 2. If count would saturate, fail. (This can only
         *    happen if count is already nonzero.)
         * 3. Otherwise, this thread is eligible for lock if
         *    it is either a reentrant acquire or
         *    queue policy allows it. If so, update state
         *    and set owner.
         */
        Thread current = Thread.currentThread();
        int c = getState();
        int w = exclusiveCount(c);
        if (c != 0) {
            // (Note: if c != 0 and w == 0 then shared count != 0)
            if (w == 0 || current != getExclusiveOwnerThread())
                return false;
            if (w + exclusiveCount(acquires) > MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            // Reentrant acquire
            setState(c + acquires);
            return true;
        }
        if (writerShouldBlock() ||
            !compareAndSetState(c, c + acquires))
            return false;
        setExclusiveOwnerThread(current);
        return true;
    }

    protected final boolean tryReleaseShared(int unused) {
        Thread current = Thread.currentThread();
        if (firstReader == current) {
            // assert firstReaderHoldCount > 0;
            if (firstReaderHoldCount == 1)
                firstReader = null;
            else
                firstReaderHoldCount--;
        } else {
            HoldCounter rh = cachedHoldCounter;
            if (rh == null || rh.tid != getThreadId(current))
                rh = readHolds.get();
            int count = rh.count;
            if (count <= 1) {
                readHolds.remove();
                if (count <= 0)
                    throw unmatchedUnlockException();
            }
            --rh.count;
        }
        for (;;) {
            int c = getState();
            int nextc = c - SHARED_UNIT;
            if (compareAndSetState(c, nextc))
                // Releasing the read lock has no effect on readers,
                // but it may allow waiting writers to proceed if
                // both read and write locks are now free.
                return nextc == 0;
        }
    }

    private IllegalMonitorStateException unmatchedUnlockException() {
        return new IllegalMonitorStateException(
            "attempt to unlock read lock, not locked by current thread");
    }

    protected final int tryAcquireShared(int unused) {
        /*
         * Walkthrough:
         * 1. If write lock held by another thread, fail.
         * 2. Otherwise, this thread is eligible for
         *    lock wrt state, so ask if it should block
         *    because of queue policy. If not, try
         *    to grant by CASing state and updating count.
         *    Note that step does not check for reentrant
         *    acquires, which is postponed to full version
         *    to avoid having to check hold count in
         *    the more typical non-reentrant case.
         * 3. If step 2 fails either because thread
         *    apparently not eligible or CAS fails or count
         *    saturated, chain to version with full retry loop.
         */
        Thread current = Thread.currentThread();
        int c = getState();
        if (exclusiveCount(c) != 0 &&
            getExclusiveOwnerThread() != current)
            return -1;
        int r = sharedCount(c);
        if (!readerShouldBlock() &&
            r < MAX_COUNT &&
            compareAndSetState(c, c + SHARED_UNIT)) {
            if (r == 0) {
                firstReader = current;
                firstReaderHoldCount = 1;
            } else if (firstReader == current) {
                firstReaderHoldCount++;
            } else {
                HoldCounter rh = cachedHoldCounter;
                if (rh == null || rh.tid != getThreadId(current))
                    cachedHoldCounter = rh = readHolds.get();
                else if (rh.count == 0)
                    readHolds.set(rh);
                rh.count++;
            }
            return 1;
        }
        return fullTryAcquireShared(current);
    }

    /**
     * Full version of acquire for reads, that handles CAS misses
     * and reentrant reads not dealt with in tryAcquireShared.
     */
    final int fullTryAcquireShared(Thread current) {
        /*
         * This code is in part redundant with that in
         * tryAcquireShared but is simpler overall by not
         * complicating tryAcquireShared with interactions between
         * retries and lazily reading hold counts.
         */
        HoldCounter rh = null;
        for (;;) {
            int c = getState();
            if (exclusiveCount(c) != 0) {
                if (getExclusiveOwnerThread() != current)
                    return -1;
                // else we hold the exclusive lock; blocking here
                // would cause deadlock.
            } else if (readerShouldBlock()) {
                // Make sure we're not acquiring read lock reentrantly
                if (firstReader == current) {
                    // assert firstReaderHoldCount > 0;
                } else {
                    if (rh == null) {
                        rh = cachedHoldCounter;
                        if (rh == null || rh.tid != getThreadId(current)) {
                            rh = readHolds.get();
                            if (rh.count == 0)
                                readHolds.remove();
                        }
                    }
                    if (rh.count == 0)
                        return -1;
                }
            }
            if (sharedCount(c) == MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            if (compareAndSetState(c, c + SHARED_UNIT)) {
                if (sharedCount(c) == 0) {
                    firstReader = current;
                    firstReaderHoldCount = 1;
                } else if (firstReader == current) {
                    firstReaderHoldCount++;
                } else {
                    if (rh == null)
                        rh = cachedHoldCounter;
                    if (rh == null || rh.tid != getThreadId(current))
                        rh = readHolds.get();
                    else if (rh.count == 0)
                        readHolds.set(rh);
                    rh.count++;
                    cachedHoldCounter = rh; // cache for release
                }
                return 1;
            }
        }
    }

    /**
     * Performs tryLock for write, enabling barging in both modes.
     * This is identical in effect to tryAcquire except for lack
     * of calls to writerShouldBlock.
     */
    final boolean tryWriteLock() {
        Thread current = Thread.currentThread();
        int c = getState();
        if (c != 0) {
            int w = exclusiveCount(c);
            if (w == 0 || current != getExclusiveOwnerThread())
                return false;
            if (w == MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
        }
        if (!compareAndSetState(c, c + 1))
            return false;
        setExclusiveOwnerThread(current);
        return true;
    }

    /**
     * Performs tryLock for read, enabling barging in both modes.
     * This is identical in effect to tryAcquireShared except for
     * lack of calls to readerShouldBlock.
     */
    final boolean tryReadLock() {
        Thread current = Thread.currentThread();
        for (;;) {
            int c = getState();
            if (exclusiveCount(c) != 0 &&
                getExclusiveOwnerThread() != current)
                return false;
            int r = sharedCount(c);
            if (r == MAX_COUNT)
                throw new Error("Maximum lock count exceeded");
            if (compareAndSetState(c, c + SHARED_UNIT)) {
                if (r == 0) {
                    firstReader = current;
                    firstReaderHoldCount = 1;
                } else if (firstReader == current) {
                    firstReaderHoldCount++;
                } else {
                    HoldCounter rh = cachedHoldCounter;
                    if (rh == null || rh.tid != getThreadId(current))
                        cachedHoldCounter = rh = readHolds.get();
                    else if (rh.count == 0)
                        readHolds.set(rh);
                    rh.count++;
                }
                return true;
            }
        }
    }

    protected final boolean isHeldExclusively() {
        // While we must in general read state before owner,
        // we don't need to do so to check if current thread is owner
        return getExclusiveOwnerThread() == Thread.currentThread();
    }

    // Methods relayed to outer class

    final ConditionObject newCondition() {
        return new ConditionObject();
    }

    final Thread getOwner() {
        // Must read state before owner to ensure memory consistency
        return ((exclusiveCount(getState()) == 0) ?
                null :
                getExclusiveOwnerThread());
    }

    final int getReadLockCount() {
        return sharedCount(getState());
    }

    final boolean isWriteLocked() {
        return exclusiveCount(getState()) != 0;
    }

    final int getWriteHoldCount() {
        return isHeldExclusively() ? exclusiveCount(getState()) : 0;
    }

    final int getReadHoldCount() {
        if (getReadLockCount() == 0)
            return 0;

        Thread current = Thread.currentThread();
        if (firstReader == current)
            return firstReaderHoldCount;

        HoldCounter rh = cachedHoldCounter;
        if (rh != null && rh.tid == getThreadId(current))
            return rh.count;

        int count = readHolds.get().count;
        if (count == 0) readHolds.remove();
        return count;
    }

    /**
     * Reconstitutes the instance from a stream (that is, deserializes it).
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        readHolds = new ThreadLocalHoldCounter();
        setState(0); // reset to unlocked state
    }

    final int getCount() { return getState(); }
}

/**
 * Fair version of Sync
 */
static final class FairSync extends Sync {
    private static final long serialVersionUID = -2274990926593161451L;
    
    final boolean writerShouldBlock() {
        // hasQueuedPredecessors() 定义在基类中 
        return hasQueuedPredecessors();
    }
    final boolean readerShouldBlock() {
          // hasQueuedPredecessors() 定义在基类中 
        return hasQueuedPredecessors();
    }
}

 /**
  * Nonfair version of Sync
  */
 static final class NonfairSync extends Sync {
     private static final long serialVersionUID = -8159625535654395037L;
     
     final boolean writerShouldBlock() {
         return false; // writers can always barge
     }
     final boolean readerShouldBlock() {
//作为一种避免无限期地饿死writer的试探法，如果暂时看起来是队列头的线程（如果存在）则阻塞，等待writer。 
 //这只是一种概率效应，因为如果在其他启用的读取器后面还没有等待中的写入器还没有从队列中耗尽，
 //那么新的读取器将不会阻塞。
         return apparentlyFirstQueuedIsExclusive();
     }
 }

/**
     * The lock returned by method {@link ReentrantReadWriteLock#readLock}.
     */
    public static class ReadLock implements Lock, java.io.Serializable {
        private static final long serialVersionUID = -5992448646407690164L;
        private final Sync sync;

        /**
         * Constructor for use by subclasses
         *
         * @param lock the outer lock object
         * @throws NullPointerException if the lock is null
         */
        protected ReadLock(ReentrantReadWriteLock lock) {
            sync = lock.sync;
        }

        /**
         * 获取读取锁定。
         * 如果写锁未被另一个线程持有，则获取读锁并立即返回。
         *
         * 如果写锁由另一个线程持有，则出于线程调度目的，当前线程将被禁用，并处于休眠状态，直到获取读锁为止。
         */
        public void lock() {
            sync.acquireShared(1);
        }

        /**
         * 除非当前线程被中断，否则获取读锁定。
         *
         * 如果写锁未被另一个线程持有，则获取读锁并立即返回。
         *
         * 如果写锁由另一个线程持有，则出于线程调度的目的，当前线程将被禁用，
         * 并处于休眠状态，直到发生以下两种情况之一：
         * 1 读取锁由当前线程获取
         * 2 其他一些线程中断当前线程。
         *
         * 如果当前线程：
         * 1 在进入此方法时设置了其中断状态 或者
         * 2 获取读锁时被中断
         * 然后抛出InterruptedException并清除当前线程的中断状态。
         *
         * 在此实现中，由于此方法是显式的中断点，因此优先于对中断的响应而不是正常或可重入的锁获取。
         *
         * @throws InterruptedException if the current thread is interrupted
         */
        public void lockInterruptibly() throws InterruptedException {
            sync.acquireSharedInterruptibly(1);
        }

        /**
         * 仅当调用时另一个线程未持有写锁时才获取读锁。
         *
         * 如果写锁未被另一个线程持有，则获取读锁，并立即返回true值。
         * 即使已将此锁设置为使用公平的排序策略，对tryLock（）的调用也会立即获取读取锁（如果可用）
         * ，无论其他线程当前是否在等待读取锁。 即使破坏公平性，
         * 这种“讨价还价”的行为在某些情况下还是有用的。
         * 如果要遵守此锁的公平性设置，请使用几乎等效的tryLock（0，TimeUnit.SECONDS）
         * （它还会检测到中断）。
         *
         * 如果写锁由另一个线程持有，则此方法将立即返回false值。
         *
         * @return {@code true} if the read lock was acquired
         */
        public boolean tryLock() {
            return sync.tryReadLock();
        }

        /**
         *如果在给定的等待时间内另一个线程未持有写锁定并且当前线程未被中断，则获取读锁定
         *
         * 如果写锁未被另一个线程持有，则获取读锁，并立即返回true值。
         * 如果已将此锁设置为使用公平的排序策略，则在任何其他线程正在等待该锁的情况下，
         * 将不会获取可用锁。 这与tryLock（）方法相反。
         * 如果您想要定时的tryLock确实允许对公平锁进行插入，则将定时和非定时形式组合在一起：
         * if (lock.tryLock() ||
         *      lock.tryLock(timeout, unit)) {
         *    ...
         *  }
         *
         *  如果写锁由另一个线程持有，则出于线程调度目的，当前线程将被禁用
         *  ，并且在发生以下三种情况之一之前，它处于休眠状态：
         *  1 读锁由当前线程获取；
         *  2 其他一些线程中断当前线程
         *  3 经过指定的等待时间
         *  如果获取了读锁，则返回值true。
         *
         *如果当前线程：
         * 1 在进入此方法时设置了其中断状态
         * 2 获取读取锁时中断
         * 然后抛出InterruptedException并清除当前线程的中断状态。
         *
         * 如果经过了指定的等待时间，则返回值false。 如果时间小于或等于零，则该方法将完全不等待
         *
         * 在此实现中，由于此方法是显式的中断点，因此优先于对中断的响应，
         * 而不是正常或可重入的锁定获取，而是优先报告等待时间的流逝
         *
         * @param timeout the time to wait for the read lock
         * @param unit the time unit of the timeout argument
         * @return {@code true} if the read lock was acquired
         * @throws InterruptedException if the current thread is interrupted
         * @throws NullPointerException if the time unit is null
         */
        public boolean tryLock(long timeout, TimeUnit unit)
                throws InterruptedException {
            return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
        }

        /**
         * 尝试释放此锁。
         *
         * <p>If the number of readers is now zero then the lock
         * is made available for write lock attempts.
         */
        public void unlock() {
            sync.releaseShared(1);
        }

        /**
         * Throws {@code UnsupportedOperationException} because
         * {@code ReadLocks} do not support conditions.
         *
         * @throws UnsupportedOperationException always
         */
        public Condition newCondition() {
            throw new UnsupportedOperationException();
        }

        /**
         * 返回标识此锁定及其锁定状态的字符串。 括号中的状态包括字符串“ Read locks =”，后跟持有的读锁的数量。
         *
         * @return a string identifying this lock, as well as its lock state
         */
        public String toString() {
            int r = sync.getReadLockCount();
            return super.toString() +
                "[Read locks = " + r + "]";
        }
    }

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * The lock returned by method {@link ReentrantReadWriteLock#writeLock}.
 */
public static class WriteLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = -4992448646407690164L;
    private final Sync sync;

    /**
     * Constructor for use by subclasses
     *
     * @param lock the outer lock object
     * @throws NullPointerException if the lock is null
     */
    protected WriteLock(ReentrantReadWriteLock lock) {
        sync = lock.sync;
    }

    /**
     * 获取写锁。
     * <p>
     * 如果读取和写入锁定均未被另一个线程持有，则获取写入锁定并立即返回，将写入锁定保持计数设置为一个
     * <p>
     * 如果当前线程已经持有写锁，那么持有计数将增加一，并且该方法将立即返回
     * <p>
     * 如果锁是由另一个线程持有的，则当前线程将出于线程调度目的而被禁用，并处于休眠状态
     * ，直到获取了写入锁为止，此时写入锁的保持计数被设置为一个。
     */
    public void lock() {
        sync.acquire(1);
    }

    /**
     * 除非当前线程被中断，否则获取写锁定。
     * <p>
     * 如果读取和写入锁定均未由另一个线程持有，则获取写入锁定并立即返回，将写入锁定保持计数设置为1。
     * <p>
     * 如果当前线程已经持有此锁，则持有计数将增加一，该方法将立即返回。
     * <p>
     * 如果锁是由另一个线程持有的，则出于线程调度的目的，当前线程将被禁用，
     * 并处于休眠状态，直到发生以下两种情况之一：
     * 1 写锁由当前线程获取；
     * 2 其他一些线程中断当前线程。
     * <p>
     * 如果当前线程获取了写锁，则将锁保持计数设置为1。
     * <p>
     * 如果当前线程：
     * 1 在进入此方法时已设置其中断状态；
     * 2 获取写锁时被中断，
     * <p>
     * 然后抛出InterruptedException并清除当前线程的中断状态。
     * <p>
     * 在此实现中，由于此方法是显式的中断点，因此优先于对中断的响应而不是正常或可重入的锁获取。
     *
     * @throws InterruptedException if the current thread is interrupted
     */
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    /**
     * 仅在调用时没有其他线程持有写锁时才获取写锁。
     * 如果读取和写入锁均未由另一个线程持有，则获取写入锁，并立即返回true值，
     * 将写入锁的保持计数设置为1。 即使已将此锁设置为使用公平的排序策略，
     * 对tryLock（）的调用也会立即获取该锁（如果可用），无论其他线程当前是否在等待写锁。
     * 即使破坏公平性，这种“讨价还价”的行为在某些情况下还是有用的。
     * 如果要遵守此锁的公平性设置，请使用几乎等效的tryLock（0，TimeUnit.SECONDS）（它还会检测到中断）。
     * <p>
     * 如果当前线程已经持有此锁，则持有计数将增加一，并且该方法返回true。
     * <p>
     * 如果锁由另一个线程持有，则此方法将立即返回false值。
     */
    public boolean tryLock() {
        return sync.tryWriteLock();
    }

    /**
     * 如果在给定的等待时间内另一个线程未持有该写锁，并且当前线程尚未中断，则获取该写锁。
     * <p>
     * 如果读取和写入锁均未由另一个线程持有，则获取写入锁，并立即返回true值，
     * 将写入锁的保持计数设置为1。 如果已将此锁定设置为使用公平的排序策略，
     * 则如果任何其他线程正在等待写锁定，则不会获取可用的锁定。
     * 这与tryLock（）方法相反。 如果您想要定时的tryLock确实允许对公平锁进行插入，则将定时和非定时形式组合在一起：
     * <p>
     * if (lock.tryLock() ||
     * lock.tryLock(timeout, unit)) {
     * ...
     * }
     * <p>
     * 如果当前线程已经持有此锁，则持有计数将增加一，并且该方法返回true。
     * <p>
     * 如果锁是由另一个线程持有的，则出于线程调度目的，当前线程将被禁用，并处于休眠状态，直到发生以下三种情况之一：
     * 1 写锁由当前线程获取
     * 2 其他一些线程中断当前线程
     * 3 经过指定的等待时间
     * <p>
     * 如果获取了写锁，则返回值true，并且将写锁保持计数设置为1。
     * <p>
     * 如果当前线程：
     * 1 在进入此方法时已设置其中断状态
     * 2 获取写锁时被中断，
     * <p>
     * 然后抛出InterruptedException并清除当前线程的中断状态。
     * <p>
     * 如果经过了指定的等待时间，则返回值false。如果时间小于或等于零，则该方法将根本不等待。
     * <p>
     * 在此实现中，由于此方法是显式的中断点，因此优先于对中断的响应而不是正常或可重入的锁定获取，而是优先报告等待时间的流逝。
     *
     * @throws InterruptedException if the current thread is interrupted
     * @throws NullPointerException if the time unit is null
     */
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

    /**
     * 如果当前线程是此锁的持有者，则保留计数将减少。
     * 如果保持计数现在为零，则释放锁定。
     * 如果当前线程不是此锁的持有者，则抛出IllegalMonitorStateException。
     *
     * @throws IllegalMonitorStateException if the current thread does not
     *                                      hold this lock
     */
    public void unlock() {
        sync.release(1);
    }

    /**
     * 返回用于此Lock实例的Condition实例。
     * <p>
     * 当与内置监视器锁定一起使用时，返回的Condition实例支持与Object监视器方法（wait，notify和notifyAll）相同的用法。
     * <p>
     * 1  如果在调用任何Condition方法时未保留此写锁定，则将抛出IllegalMonitorStateException。
     * （读锁独立于写锁而持有，因此不会被检查或受影响。但是，当当前线程也已获取读锁时
     * ，调用条件等待方法本质上总是错误，因为其他可能解除阻塞它的线程不会被调用。能够获取写锁。）
     * <p>
     * 2 当条件等待方法被调用时，写锁被释放，并且在返回之前，将重新获取写锁，并将锁保持计数恢复为调用该方法时的状态。
     * <p>
     * 3 如果线程在等待时被中断，则等待将终止，将抛出InterruptedException，并清除线程的中断状态，并以FIFO顺序发出等待线程的信号。
     * <p>
     * 4 从等待方法返回的线程的锁重新获取顺序与最初获取锁的线程的顺序相同（默认情况下未指定），但对于公平锁，优先使用等待时间最长的线程。
     *
     * @return the Condition object
     */
    public Condition newCondition() {
        return sync.newCondition();
    }

    /**
     * Returns a string identifying this lock, as well as its lock
     * state.  The state, in brackets includes either the String
     * {@code "Unlocked"} or the String {@code "Locked by"}
     * followed by the {@linkplain Thread#getName name} of the owning thread.
     *
     * @return a string identifying this lock, as well as its lock state
     */
    public String toString() {
        Thread o = sync.getOwner();
        return super.toString() + ((o == null) ?
                "[Unlocked]" :
                "[Locked by thread " + o.getName() + "]");
    }

    /**
     * Queries if this write lock is held by the current thread.
     * Identical in effect to {@link
     * ReentrantReadWriteLock#isWriteLockedByCurrentThread}.
     *
     * @return {@code true} if the current thread holds this lock and
     * {@code false} otherwise
     * @since 1.6
     */
    public boolean isHeldByCurrentThread() {
        return sync.isHeldExclusively();
    }

    /**
     * Queries the number of holds on this write lock by the current
     * thread.  A thread has a hold on a lock for each lock action
     * that is not matched by an unlock action.  Identical in effect
     * to {@link ReentrantReadWriteLock#getWriteHoldCount}.
     *
     * @return the number of holds on this lock by the current thread,
     * or zero if this lock is not held by the current thread
     * @since 1.6
     */
    public int getHoldCount() {
        return sync.getWriteHoldCount();
    }
}

//查询当前线程对该写锁的保留数
int	getHoldCount()

//查询当前线程是否拥有此写锁定。
boolean	isHeldByCurrentThread()