读写锁ReentrantReadWriteLock简介
ReentrantReadWriteLock是ReadWriteLock接口的实现，ReentrantReadWriteLock中有两个静态内部类：ReadLock读锁和WriteLock写锁，这两个锁实现了Lock接口，ReentrantReadWriteLock支持可重入，同步功能依赖自定义同步器（AbstractQueuedSynchronizer）实现，读写状态就是其同步器的同步状态。同步状态由一个整型变量表示，因为这个变量需要表示多个线程的读和写的状态，因此读写锁在实现上将该变量的高16位表示读，低16位表示写。
写锁的获取和释放
写锁WriteLock是支持重进入的排他锁。如果当前线程已经获取了写锁，则增加写状态。如果当前线程在获取读锁时，读锁已经被获取或者该线程不是已获取写锁的线程，则当前线程进入等待状态。读写锁确保写锁的操作对读锁可见。写锁释放每次减少写状态，当前写状态为0时表示写锁已背释放。
读锁的获取与释放
读锁ReadLock是支持重进入的共享锁，它能够被多个线程同时获取，在没有其他写线程访问（写状态为0）时，读锁总是能够被成功地获取，而所做的也只是增加读状态（线程安全）。如果当前线程已经获取了读锁，则增加读状态。如果当前线程在获取读锁时，写锁已经被获取，则进入等待状态。
锁降级
锁降级指的是写锁降级成为读锁。锁降级是指把持住当前拥有的写锁的同时，再获取到读锁，随后释放写锁的过程。以下是oracle官网的对于锁降级的示例代码：
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();
}
}
}
代码中声明了一个volatile类型的cacheValid变量，保证其可见性。首先获取读锁，如果cache不可用，则释放读锁，获取写锁，在更改数据之前，再检查一次cacheValid的值，然后修改数据，将cacheValid置为true，然后在释放写锁前获取读锁；此时，cache中数据可用，处理cache中数据，最后释放读锁。这个过程就是一个完整的锁降级的过程，目的是保证数据可见性，如果当前的线程C在修改完cache中的数据后，没有获取读锁而是直接释放了写锁，那么假设此时另一个线程T获取了写锁并修改了数据，那么C线程无法感知到数据已被修改，则数据出现错误。如果遵循锁降级的步骤，线程C在释放写锁之前获取读锁，那么线程T在获取写锁时将被阻塞，直到线程C完成数据处理过程，释放读锁。
示例
以上的处理过程稍显抽象，因此，我写了一个具体的案例来演示以上过程，代码如下：
public class ReadWriteLockTest {
private volatile boolean cacheValid = false;
private int currentValue = 0;
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private Lock readLock = lock.readLock();
private Lock writeLock = lock.writeLock();
/**
* 测试用例
* @throws InterruptedException
*/
@Test
public void testLockDowngrading() throws InterruptedException {
CountDownLatch start = new CountDownLatch(1);
CountDownLatch end = new CountDownLatch(2);
ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 10, 100, TimeUnit.SECONDS, new ArrayBlockingQueue
(10));
for (int i = 0; i < 2; i ++){
int finalI = i;
executor.execute(new Thread(new Runnable() {
@Override
public void run() {
Thread.currentThread().setName("thread-" + finalI);
try {
start.await();
TimeUnit.SECONDS.sleep(finalI);
System.out.println("after sleep " + finalI + " seconds, excute " + Thread.currentThread().getName());
cacheValid = false;
processCachedData(finalI);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
end.countDown();
}
}
}));
}
start.countDown();
end.await();
}
/**
* 锁降级过程
* @param num
*/
private void processCachedDataDownGrading(int num){
readLock.lock();
if(!cacheValid){
//必须先释放写锁
readLock.unlock();
writeLock.lock();
try{
//在更新数据之前做二次检查
if(!cacheValid){
System.out.println(Thread.currentThread().getName() + " has updated!");
//将数据更新为和线程值相同，以便验证数据
currentValue = num;
cacheValid = true;
readLock.lock();
}
}finally {
writeLock.unlock();
}
}
try{
//模拟5秒的处理时间，并打印出当前值，在这个过程中cacheValid可能被其他线程修改，锁降级保证其他线程写锁被阻塞，数据不被改变
TimeUnit.SECONDS.sleep(5);
System.out.println(Thread.currentThread().getName() + ": " + currentValue);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(lock.getReadHoldCount() > 0){
readLock.unlock();
}
}
}
/**
* 无锁降级的过程
* @param num
*/
private void processCachedData(int num){
readLock.lock();
if(!cacheValid){
readLock.unlock();
writeLock.lock();
try{
if(!cacheValid){
System.out.println(Thread.currentThread().getName() + " has updated!");
currentValue = num;
cacheValid = true;
}
}finally {
writeLock.unlock();
}
}
try{
//模拟5秒的处理时间，并打印出当前值，在这个过程中cacheValid可能被其他线程修改，无锁降级过程，其他线程此时可能获取写锁，并更改书数据，导致后面的数据错误
TimeUnit.SECONDS.sleep(5);
System.out.println(Thread.currentThread().getName() + ": " + currentValue);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
if(lock.getReadHoldCount() > 0){
readLock.unlock();
}
}
}
}
在上述的测试代码中，有两个方法，一个是processCachedDataDownGrading，该方法模拟锁降级的过程，另一个是processCachedData，模拟无锁降级的过程。
在主测试代码中，起了两个线程，每个线程执行前先将cacheValid置为false，同时，为了模拟处理数据5秒中外部线程的想要执行的数据变更，两个线程的实际执行行为相差1秒。
如果两个线程中执行的方法是processCachedData（无锁降级过程），那么输出为：
after sleep 0 seconds, excute thread-0
thread-0 has updated!
after sleep 1 seconds, excute thread-1
thread-1 has updated!
thread-0: 1
thread-1: 1
从输出看，线程0马上执行（不是指run前，指run中我们想测试的内容），线程1过了1秒执行，两个线程中的数据均被改变，但是最终两个线程中的值均为1（实际我们期望线程0中的数据应该为0），导致这个结果的原因就是在线程0处理数据（sleep5秒）的过程中，线程1获取了写锁并更新了数据，从而线程0的数据被更新。
如果两个线程中执行的方法是processCachedDataDownGrading（锁降级过程），那么输出为：
after sleep 0 seconds, excute thread-0
thread-0 has updated!
after sleep 1 seconds, excute thread-1
thread-0: 0
thread-1 has updated!
thread-1: 1
从输出看，线程0马上执行，线程1过了1秒执行，两个线程中的数据均被改变，但是最终两个线程中的值分别为0和1，符合期望，因为这个过程是锁降级的过程，线程0在更新数据之后，释放写锁之前，获取了读锁，并在处理完数据之后才将其释放，因此线程1在线程0在处理数据时获取写锁被阻塞，从thread-1 has updated! 语句输出在thread-0: 0 之后也可看出，从而保证了数据0的数据没有问题。
以上是我个人的一些理解，如有问题，欢迎邮件至[email protected]探讨，多谢！