Thread之锁降级

锁降级

锁降级是指持有写锁的同时，再获取读锁，最后释放写锁的过程。反之持有写锁，释放写锁，获取读锁的过程不是锁降级。锁降级的应用场景是数据不常变化，多线程可以并发处理数据。数据变更后，如果当前线程感知数据变化，则进行数据准备工作，同时其他线程被阻塞。锁降级的目的是数据准备完毕，释放写锁之前，获取读锁以感知其他线程对数据的更新。

可降级的原因

写锁为可重入的拍他锁，读锁为可重入的共享锁，之所以写锁可降级为读锁，是因为ReentrantReadWriteLock扩展于Lock，而Lock聚集了同步器AbstractQueuedSynchronizer。同步器作为读写锁的内部类，读锁所调用的同步器的tryAcquireShared方法和写锁调用的同步器的tryAcquire方法，在已有锁和持锁线程的判断逻辑是不同的，如下（仅留下关键部分，其他略）。

int tryAcquireShared() {
    for(;;) { 
        int c = getState();
        ...
        if (exclusiveCount(c) !=0 && owner != Thread.currentThread()) {
            return -1;
        }
        ...
    }
}
方法中进行逻辑判断，如果存在其他线程已经获取了写锁，读锁获取失败，但存在一种情况如果本线程已经获取了写锁，可以再获取读锁。

boolean tryAcquire() {
    Thread current = Thread.currentThread();
    int c = getState();
    int w = exclusiveCount(c);
    if (c != 0) {
        if (w == 0 || current != getExclusiveOwnerThread()) {
            return false;
        }
        ...
    }
    ...
}
方法逻辑判断中，如果w==0即获取写锁之前已经存在读锁，则写锁获取失败，因此持有读锁后，任意线程均不能获取写锁。另一判断逻辑是当前线程不是持有写锁的线程，获取写锁也将失败。

实例

package lockdegrade;

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class LockDegrade {
    private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private static ReadLock r = lock.readLock();
    private static WriteLock w = lock.writeLock();
    private volatile boolean update = false;

    public void processData() {
        r.lock();
        if (!update) {
            r.unlock();
            w.lock();
            try {
                if (!update) {
                    //数据准备
                    update = true;
                }
                r.lock();
            } finally {
                w.unlock();
            }
            //完成锁降级，写锁降级为读锁
            try {
                //数据逻辑处理
            } finally {
                r.unlock();
            }
        }
    }
}