可重入锁、读写锁

ReentrantLock：重入锁。表示该锁能够支持一个线程对资源的重复加锁.任意线程在获取到锁之后能够再次获取该所而不会被锁阻塞。
之前写的Mutex是一个不支持的重入的独占锁。

1. 实现可重入
   线程再次加锁：锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次获取。
   锁的最终释放：线程重复N此获取了锁，随后在第N次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数增加，计数表示当前锁被重复获取的次数，而被锁释放的时候，计数自减，当计数等于0的时候表示锁已经成功释放。

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

查看源码发现：通过判断当前线程是否为获取锁的线程来决定操作是否成功，如果是获取锁的线程再次请求，则将同步值进行增加并返回true。表示获取成功
成功获取锁的线程再次获取锁，只是增加了同步状态值。

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

如果该多被获取了N次，那么前N-1次tryRelease都返回false，只有同步状态完全释放（等于0）才可以返回true。
公平锁

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

该方法与非公平锁的区别：判断条件加了hasQueuedPredecessors。即加入了同步队列中当前节点是否有前驱结点的判断。如果该方法返回true。说明之前有更早的线程请求获取锁，因此需要等待前驱线程获取并释放或才可以去获取。

读写锁

之前学的独占锁可重入锁都是排它锁。这些锁在同一时刻只允许一个线程进行访问，而读写锁在同一时刻允许多个线程访问，但是在写线程访问时，所有的读操作和其他写操作均被堵塞。

方法名称	描述
int getReadLockCount()	返回当前锁被获取的次数。该次数不等于获取读锁的线程数，比如，仅一个线程，它连续获取了N次读锁，那么占据读锁的线程是1，但是该方法返回N。
int getReadHoldCount()	返回当前线程获取读锁的次数
boolean isWriteLock	判断写锁是否被获取
int getWriteHoldCount()	返回当前锁被获取的次数

读写锁的使用

public class Cache {
    static Map<String, Object> map = new HashMap<>();
    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock r = rwl.readLock();
    static Lock w = rwl.writeLock();

    public static final Object get(String key) {
        r.lock();
        try {
            return map.get(key);
        } finally {
            r.unlock();
        }
    }

    //设置key对应的value，并返回旧的value
    public static final Object put(String key, Object value) {
        w.lock();
        try {
            return map.put(key, value);
        } finally {
            w.unlock();
        }
    }

    //清空所有内容
    public static final void clear() {
        w.lock();
        try {
            map.clear();
        } finally {
            w.unlock();
        }
    }

}