重入锁
重入锁ReentrantLock，表示该锁能够支持一个线程对资源的重复加锁。支持获取锁时的公平和非公平性选择。
synchronized关键字隐式的支持重进入，比如一个synchronized修饰的递归方法，在方法执行时，执行线程在获取了锁之后仍能连续多次地获得该锁。
ReentrantLock虽然没能像synchronized关键字一样支持隐式的重进入，但是在调用lock()方 法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞。
实现重进入
重进入是指任意线程在获取到锁之后能够再次获取该锁而不会被锁阻塞。
（1）线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。
（2）锁的最终释放。线程重复n此获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次所，而锁被释放时，计数自减，当计数等于0时表示锁已经成功释放。
非公平性（默认）
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
if (compareAndSetState(0, acquires)) { CAS设置同步状态，即获取锁
setExclusiveOwnerThread(current); 记录当前线程
return true;
}
}
else if (current == getExclusiveOwnerThread()) {如果是获取锁的线程再次请求，则将同步状态值进行增加并返回 true，表示获取同步状态成功。
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) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread()) 判断当前线程是否为获得锁的线程
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) { 最终释放条件c=0
free = true;
setExclusiveOwnerThread(null); 清空获得锁的线程
}
setState(c);
return free; 如果该锁被获取锁被获取了n次，那么前（n-1）次都返回false，只有同步状态完全被释放，才返回true
}
公平与非公平获取锁的区别
公平性与否是针对获取锁而言的，如果一个锁是公平的，那么获取锁的顺序就应该符合请求的绝对时间顺序，也就是FIFO
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;
}
该方法与nonfairTryAcquire(int acquires)比较，唯一不同的位置为判断条件多了 hasQueuedPredecessors()方法，即加入了同步队列中当前节点是否有前驱节点的判断，如果该 方法返回true，则表示有线程比当前线程更早地请求获取锁，因此需要等待前驱线程获取并释 放锁之后才能继续获取锁。
读写锁
ReadWriteLock仅定义了获取读锁和写锁的两个方法，即readLock（）方法和writeLock方法，而其实现ReentrantReadWriteLcok。
| 方法名称 | 描述 |
|---|---|
| int getReadLockCount（） | 返回当前读锁被获取的次数。该次数不等于获取读锁的线程数，例如，仅一个线程，它连续获取（重进入）了n次读锁，那么占据读锁的先储层数是1，但该方法返回n |
| int getReadHoldCount（） | 返回当前线程获取读锁的次数。该方法在Java6中加入到ReentrantReadWriteLock中，使用TreadLocal保存当前线程获取的次数，这也使得Java6的实现变得更加复杂 |
| boolean isWriteLocked（） | 判断写锁是否被获取 |
| int getWriteHoldCount（） | 返回当前写锁被获取的次数 |
public class Cache {
static Map<String,Object> map=new HashMap<>();
static ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock();
static Lock r=readWriteLock.readLock();
static Lock w=readWriteLock.writeLock();
获取一个key对应的value
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,String 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();
}
}
}
Cache组合一个非线程安全的HashMap作为缓存的实现，同时使用读写锁的读锁和写锁来保证Cache是线程安全的。在读操作的get（String key）方法中，获取读锁，这使得并发访问该方法时不会被阻塞。写操作put(String key,Object value)方法和clear()方法，在更新 HashMap时必须提前获取写锁，当获取写锁后，其他线程对于读锁和写锁的获取均被阻塞，而 只有写锁被释放之后，其他读写操作才能继续。Cache使用读写锁提升读操作的并发性，也保 证每次写操作对所有的读写操作的可见性，同时简化了编程方式。
读写锁的实现分析
读写状态的设计、写锁的获取与释放、读锁的获取与释放以及锁降级
读写状态的设计
读写锁同样依赖自定义同步器来实现同步功能，而读写状态就是其同步器的同步状态。
如果在一个整型变量上维护多种状态，就一定需要“按位切割使用”这个变量，读写锁将变量切分成了两个部分，高16位表示读，低16位表示写。
当前同步状态表示一个线程已经获取了写锁，且重进入了两次，同步也连续获取了两次读锁。
通过位运算，确定读写各自状态。
假设当前同步状态值位S，写状态等于S&0X0000FFFF(将高16位全部抹去)，读状态等于S>>>(无符号补0右移16位)。
当写状态增加1时，等于S+1，当读状态增加1时，等于S+（1<<16），也就是S+0x00010000
根据状态的划分能得出一个推论：S不等于0时，当写状态（S&0x0000FFFF）等于0时，则读 状态（S>>>16）大于0，即读锁已被获取。
写锁的获取与释放
写锁是一个支持重进入的排它锁。如果当前线程已经获取了写锁，则增加写状态。如果当前线程在获取写锁时，读锁已经被获取（读状态不为0）或者该线程不是已经获取写锁的线程，则当前线程进入等待状态。
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;
}
读锁的获取与释放
读锁是一个支持重进入的共享锁，它能够被多个线程同时获取，在没有其他写线程访问（或者写状态为0）时，读锁总会被成功地获取，而所做的也只是（线程安全的）增加读状态。如果当前线程已经获取了读锁，则增加读状态。如果当前线程在获取读锁时，写锁已被其他线程获取，则进入等待状态。
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);
}
在tryAcquireShared(int unused)方法中，如果其他线程已经获取了写锁，则当前线程获取读锁失败，进入等待状态。如果当前线程获取了写锁或者写锁未被获取，则当前线程（线程安全， 依靠CAS保证）增加读状态，成功获取读锁。 读锁的每次释放（线程安全的，可能有多个读线程同时释放读锁）均减少读状态，减少的值是（1<<16）。
锁降级
锁降级指的是写锁降级成为读锁。如果当前线程拥有写锁，然后将其释放，最后再获取读锁，这种分段完成的过程不能称之为锁降级。锁降级是指把持住（当前拥有的）写锁，再获取到读锁，随后释放（先前拥有的）写锁的过程。
