基础
- 读写锁的定义：对于读锁的获取，即使已经有线程获取了读锁，当前线程也可以获取成功；对于写锁的获取，如果已有线程获取了写锁或者其他线程获取了读锁，那么写锁获取失败；读锁写锁是互斥的。
demo
基于非线程安全的HashMap和读写锁实现的线程安全的缓存容器。
public class Cache {
private HashMap map;
private Lock writeLock;
private Lock readLock;
public Cache(){
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
writeLock = lock.writeLock();
readLock = lock.readLock();
}
public Object get(String key){
readLock.lock();
try {
return map.get(key);
}finally {
readLock.unlock();
}
}
public void put(String key, Object value){
writeLock.lock();
try{
map.put(key, value);
}finally {
writeLock.unlock();
}
}
}
读写锁(以ReentrantReadWriteLock为例)实现分析
状态变量设计
显然读写锁需要共用同一个状态变量（使用AQS作为底层实现），所以我们需要把AQS中的state变量分为两部分一部分用于维护读线程的状态信息，另一部分维护写线程的状态信息。
ReentrantReadWriteLock 中将state变量的低16位用于写线程，高16位用于读线程。所以假设当前同步变量状态位S，那么读状态+1时， S = S + (1<<16);当写状态+1时，S = S+1；
推论：当 S !=0 时，且写状态（S&0X0000FFFF）等于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);//获取写状态（同步变量的低16位，位运算获取）
if (c != 0) {
// (Note: if c != 0 and w == 0 then shared count != 0)
//这里代表有线程获得了读锁（w==0 & c != 0）
//或者有其他线程获得了写锁（current != getExclusiveOwnerThread()）
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 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);
}
锁降级
定义：把持写锁，再获取到读锁，再释放写锁。
意义：写锁释放之前把持读锁，可以保证数据的可见性，应用场景？
下午书中示例
public void processData() {
readLock.lock();
if (!update) {
// 必须先释放读锁
readLock.unlock();
// 锁降级从写锁获取到开始
writeLock.lock();
try {
if (!update) {
// 准备数据的流程（略）
update = true;
}
readLock.lock();
} finally {
writeLock.unlock();
}
// 锁降级完成，写锁降级为读锁
}
try {
// 使用数据的流程（略）
} finally {
readLock.unlock();
}
}
问题
- 为什么获取读写锁读锁被获取之后，不能获取写锁？
因为要保证写锁的操作对读锁可见，数据可见性。 - 为什么不能锁升级，为什么可以锁降级？
- 为什么需要锁降级？
