-
锁降级
锁降级是指写锁降级为读锁。
在写锁没有释放的时候，获取到读锁，再释放写锁 -
锁升级(ReentrantReadWriteLock是不支持的。)
把读锁升级为写锁
在读锁没有释放的时候，获取到写锁，再释放读锁 -
oracle官网的对于锁降级的示例代码：
class CachedData {
Object data;
volatile boolean cacheValid;
final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
void processCachedData() {
rwl.readLock().lock();
if (!cacheValid) {
rwl.readLock().unlock();
rwl.writeLock().lock();
try {
if (!cacheValid) {
data = ...
cacheValid = true;
}
rwl.readLock().lock();
} finally {
rwl.writeLock().unlock();
}
}
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();
/**
* 测试用例
*/
@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
<Runnable>(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的数据没有问题。