30.读写锁模式：高并发场景的“图书馆管理系统“

“好的并发控制应该像图书馆管理——允许大量读者同时阅读，但确保作者修改内容时拥有专属空间” —— 《Java并发编程实战》作者

一、当缓存系统遇到性能瓶颈

假设我们正在构建一个股票行情系统，初期实现：

public class StockCache {
    private Map<String, Double> prices = new HashMap<>();
    private final ReentrantLock lock = new ReentrantLock();

    // 读取股票价格（被过度保护）
    public Double getPrice(String stockCode) {
        lock.lock();
        try {
            return prices.get(stockCode);
        } finally {
            lock.lock();
        }
    }

    // 更新股票价格
    public void updatePrice(String stockCode, Double price) {
        lock.lock();
        try {
            prices.put(stockCode, price);
        } finally {
            lock.unlock();
        }
    }
}

问题诊断：

1. 读操作占用了99%的请求
2. 极端情况下出现200ms的读延迟
3. CPU利用率不足30%
4. 高峰期每秒只能处理500次请求

二、六种实现方案大比拼

2.1 基础版：ReentrantReadWriteLock

public class ReadWriteCache {
    private Map<String, Double> data = new HashMap<>();
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final Lock readLock = rwLock.readLock();
    private final Lock writeLock = rwLock.writeLock();

    // 获取读锁（共享）
    public Double get(String key) {
        readLock.lock();
        try {
            return data.get(key);
        } finally {
            readLock.unlock();
        }
    }

    // 获取写锁（独占）
    public void put(String key, Double value) {
        writeLock.lock();
        try {
            data.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }

    // 锁降级示例
    public void updateWithDowngrade(String key, Double value) {
        writeLock.lock();
        try {
            // 写操作
            data.put(key, value);
            // 获取读锁（此时仍然持有写锁）
            readLock.lock();
        } finally {
            writeLock.unlock();
        }
        try {
            // 读操作（此时只持有读锁）
            validateData(key);
        } finally {
            readLock.unlock();
        }
    }
}

2.2 升级版：StampedLock

public class StampedCache {
    private Map<String, Double> data = new HashMap<>();
    private final StampedLock stampedLock = new StampedLock();

    // 乐观读
    public Double optimisticGet(String key) {
        long stamp = stampedLock.tryOptimisticRead();
        Double value = data.get(key);
        if (!stampedLock.validate(stamp)) {
            // 升级为悲观读
            stamp = stampedLock.readLock();
            try {
                return data.get(key);
            } finally {
                stampedLock.unlockRead(stamp);
            }
        }
        return value;
    }

    // 写操作
    public void write(String key, Double value) {
        long stamp = stampedLock.writeLock();
        try {
            data.put(key, value);
        } finally {
            stampedLock.unlockWrite(stamp);
        }
    }

    // 锁升级示例
    public void updateWithUpgrade(String key, Double delta) {
        long stamp = stampedLock.readLock();
        try {
            while (true) {
                Double current = data.get(key);
                long ws = stampedLock.tryConvertToWriteLock(stamp);
                if (ws != 0L) {
                    stamp = ws;
                    data.put(key, current + delta);
                    return;
                } else {
                    stampedLock.unlockRead(stamp);
                    stamp = stampedLock.writeLock();
                }
            }
        } finally {
            stampedLock.unlock(stamp);
        }
    }
}

2.3 自定义版：基于AQS实现

public class CustomReadWriteLock {
    private static final int READER_MASK = 0x00FF;
    private static final int WRITER_MASK = 0xFF00;
    
    private final AtomicInteger state = new AtomicInteger(0);

    public void lockRead() throws InterruptedException {
        while (true) {
            int current = state.get();
            if ((current & WRITER_MASK) == 0) {
                if (state.compareAndSet(current, current + 1)) {
                    return;
                }
            }
            Thread.yield();
        }
    }

    public void unlockRead() {
        state.decrementAndGet();
    }

    public void lockWrite() throws InterruptedException {
        while (true) {
            int current = state.get();
            if (current == 0) {
                if (state.compareAndSet(current, WRITER_MASK)) {
                    return;
                }
            }
            Thread.yield();
        }
    }

    public void unlockWrite() {
        state.addAndGet(-WRITER_MASK);
    }
}

2.4 分布式版：Redisson实现

public class DistributedCache {
    private final RedissonClient redisson;
    private final RMap<String, Double> map;

    public DistributedCache() {
        Config config = new Config();
        config.useClusterServers().addNodeAddress("redis://127.0.0.1:7001");
        redisson = Redisson.create(config);
        map = redisson.getMap("stockPrices");
    }

    public Double get(String key) {
        RReadWriteLock rwLock = redisson.getReadWriteLock(key);
        RLock rLock = rwLock.readLock();
        try {
            rLock.lock();
            return map.get(key);
        } finally {
            rLock.unlock();
        }
    }

    public void put(String key, Double value) {
        RReadWriteLock rwLock = redisson.getReadWriteLock(key);
        RLock wLock = rwLock.writeLock();
        try {
            wLock.lock();
            map.put(key, value);
        } finally {
            wLock.unlock();
        }
    }
}

2.5 性能优化版：volatile增强

public class VolatileEnhancedCache {
    private volatile Map<String, Double> snapshot = Collections.emptyMap();
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();

    // 读操作完全无锁
    public Double get(String key) {
        return snapshot.get(key);
    }

    // 写操作
    public void refreshData() {
        rwLock.writeLock().lock();
        try {
            Map<String, Double> newData = loadFromDatabase();
            // 创建不可变快照
            snapshot = Collections.unmodifiableMap(newData);
        } finally {
            rwLock.writeLock().unlock();
        }
    }

    // 数据库查询（模拟）
    private Map<String, Double> loadFromDatabase() {
        // 返回新数据副本
        return new HashMap<>(...); 
    }
}

2.6 ThreadLocal缓存版

public class ThreadLocalCache {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private Map<String, Double> data = new HashMap<>();
    private final ThreadLocal<Map<String, Double>> localCache = ThreadLocal.withInitial(HashMap::new);

    public Double getWithCache(String key) {
        // 首先检查线程本地缓存
        Map<String, Double> cache = localCache.get();
        if (cache.containsKey(key)) {
            return cache.get(key);
        }

        rwLock.readLock().lock();
        try {
            Double value = data.get(key);
            cache.put(key, value);
            return value;
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void update(String key, Double value) {
        rwLock.writeLock().lock();
        try {
            data.put(key, value);
            // 清除所有线程的本地缓存
            localCache.remove(); 
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

三、性能优化五大秘籍

3.1 读多写少场景优化

public class BatchUpdater {
    private final StampedLock lock = new StampedLock();
    private Map<String, Double> data = new ConcurrentHashMap<>();

    // 批量更新方法
    public void batchUpdate(Map<String, Double> updates) {
        long stamp = lock.writeLock();
        try {
            updates.forEach((k, v) -> data.put(k, v));
        } finally {
            lock.unlockWrite(stamp);
        }
    }

    // 批量查询方法
    public Map<String, Double> batchGet(Set<String> keys) {
        long stamp = lock.tryOptimisticRead();
        Map<String, Double> result = new HashMap<>();
        keys.forEach(k -> result.put(k, data.get(k)));
        
        if (!lock.validate(stamp)) {
            stamp = lock.readLock();
            try {
                result.clear();
                keys.forEach(k -> result.put(k, data.get(k)));
            } finally {
                lock.unlockRead(stamp);
            }
        }
        return result;
    }
}

3.2 公平性调优策略

public class FairReadWriteLockExample {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock(true); // 公平模式

    public void fairRead() {
        rwLock.readLock().lock();
        try {
            // 读操作
        } finally {
            rwLock.readLock().unlock();
        }
    }

    public void fairWrite() {
        rwLock.writeLock().lock();
        try {
            // 写操作
        } finally {
            rwLock.writeLock().unlock();
        }
    }
}

3.3 锁分段技术

public class StripedCache {
    private final List<ReadWriteLock> lockStripes = 
        IntStream.range(0, 16)
                 .mapToObj(i -> new ReentrantReadWriteLock())
                 .collect(Collectors.toList());

    private final Map<String, Double> data = new HashMap<>();

    private ReadWriteLock getLock(String key) {
        int stripe = Math.abs(key.hashCode()) % lockStripes.size();
        return lockStripes.get(stripe);
    }

    public Double get(String key) {
        ReadWriteLock lock = getLock(key);
        lock.readLock().lock();
        try {
            return data.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }

    public void put(String key, Double value) {
        ReadWriteLock lock = getLock(key);
        lock.writeLock().lock();
        try {
            data.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }
}

3.4 监控告警机制

public class MonitoredReadWriteLock extends ReentrantReadWriteLock {
    private final AtomicLong readWaitTime = new AtomicLong();
    private final AtomicLong writeWaitTime = new AtomicLong();

    @Override
    public Lock readLock() {
        return new MonitoringLock(super.readLock(), readWaitTime);
    }

    @Override
    public Lock writeLock() {
        return new MonitoringLock(super.writeLock(), writeWaitTime);
    }

    class MonitoringLock implements Lock {
        private final Lock delegate;
        private final AtomicLong metric;

        MonitoringLock(Lock delegate, AtomicLong metric) {
            this.delegate = delegate;
            this.metric = metric;
        }

        @Override
        public void lock() {
            long start = System.nanoTime();
            delegate.lock();
            metric.addAndGet(System.nanoTime() - start);
        }

        // 实现其他Lock接口方法...
    }
}

3.5 读写优先级控制

public class WritePreferredReadWriteLock {
    private int activeReaders = 0;
    private int waitingWriters = 0;
    private boolean activeWriter = false;

    public synchronized void lockRead() throws InterruptedException {
        while (activeWriter || waitingWriters > 0) {
            wait();
        }
        activeReaders++;
    }

    public synchronized void unlockRead() {
        activeReaders--;
        notifyAll();
    }

    public synchronized void lockWrite() throws InterruptedException {
        waitingWriters++;
        while (activeReaders > 0 || activeWriter) {
            wait();
        }
        waitingWriters--;
        activeWriter = true;
    }

    public synchronized void unlockWrite() {
        activeWriter = false;
        notifyAll();
    }
}

四、避坑指南：五个血泪教训

1. 锁升级陷阱
   错误的锁升级顺序会导致死锁：

// 错误示例！
readLock.lock();
try {
    // 尝试获取写锁
    writeLock.lock(); // 这里会永久阻塞！
} finally {
    readLock.unlock();
}

2. 缓存一致性难题
   采用CopyOnWrite模式时的内存消耗问题：

public class CopyOnWriteCache {
    private volatile List<String> data = new ArrayList<>();
    
    public void update() {
        List<String> newData = new ArrayList<>(data); // 大集合时性能骤降
        newData.add("newItem");
        data = newData;
    }
}

3. 线程饥饿风险
   不公平锁导致的写线程饥饿：

// 一直有读请求时，写线程可能永远无法获得锁
new ReentrantReadWriteLock(false); // 默认非公平模式

4. 分布式锁误区
   网络分区时的锁失效问题：

// Redis分布式锁示例（伪代码）
String result = jedis.set(lockKey, requestId, "NX", "PX", expireTime);
if ("OK".equals(result)) {
    // 获得锁期间可能发生网络分区...
    // 锁超时自动释放导致数据不一致
}

5. 性能监控盲区
   忽视锁竞争指标的后果：

// 使用JMX监控锁状态
ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
ManagementFactory.getPlatformMBeanServer().registerMBean(
    new LockMonitor(lock), 
    new ObjectName("com.example:type=LockMonitor")
);

五、实战测试：百万级并发挑战

public class ReadWriteLockBenchmark {
    private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
    private int value;

    @Benchmark
    @Threads(8)
    public void testRead() {
        rwLock.readLock().lock();
        try {
            // 模拟读操作耗时
            Blackhole.consumeCPU(1000);
        } finally {
            rwLock.readLock().unlock();
        }
    }

    @Benchmark
    @Threads(2)
    public void testWrite() {
        rwLock.writeLock().lock();
        try {
            value++;
            Blackhole.consumeCPU(2000);
        } finally {
            rwLock.writeLock().unlock();
        }
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
            .include(ReadWriteLockBenchmark.class.getSimpleName())
            .forks(1)
            .warmupIterations(5)
            .measurementIterations(5)
            .build();
        new Runner(opt).run();
    }
}

测试结果分析（基于4核CPU）：

六、灵魂拷问：你的系统适合哪种方案？

当遇到以下场景时，该如何选择？

1. 需要实时数据一致性保证
2. 读操作耗时超过10ms
3. 存在跨数据中心的读写
4. 需要支持事务性更新
5. 系统资源极度受限