解释读写锁（ReadWriteLock）的概念及其工作原理。

八股文_Java并发基础题 0 3

参考回答

读写锁（ReadWriteLock） 是 Java 中用于提升并发性能的一种锁机制。它允许多个线程同时读取共享资源（读操作），但在写操作时，只允许一个线程访问资源，并阻止其他线程的读写操作。

关键点：

读操作共享：多个线程可以同时获取读锁，只要没有线程持有写锁。
写操作独占：只有一个线程可以持有写锁，同时阻止其他线程获取读锁或写锁。
读写互斥：读锁和写锁不能同时持有，确保数据的一致性。

ReadWriteLock 的典型实现是 ReentrantReadWriteLock。

工作原理

ReadWriteLock 提供了两种锁：

读锁（共享锁）：允许多个线程同时持有。
写锁（独占锁）：只能被一个线程持有。

基本规则

当一个线程持有写锁时，其他线程无法获取读锁或写锁。
当一个线程持有读锁时，其他线程可以继续获取读锁，但无法获取写锁。
写锁优先级（可选）：可以设置为写锁优先，避免读操作长期占用导致写操作“饥饿”。

读写锁的状态管理

读锁计数：记录当前持有读锁的线程数量。
写锁状态：标记当前是否有线程持有写锁。

示例：使用 ReentrantReadWriteLock

1. 基本用法

以下示例展示了 ReentrantReadWriteLock 的基本使用，模拟了多线程的读写操作。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private int sharedData = 0;

    public void readData() {
        lock.readLock().lock(); // 获取读锁
        try {
            System.out.println(Thread.currentThread().getName() + " is reading: " + sharedData);
            Thread.sleep(100); // 模拟读操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock(); // 释放读锁
        }
    }

    public void writeData(int value) {
        lock.writeLock().lock(); // 获取写锁
        try {
            System.out.println(Thread.currentThread().getName() + " is writing: " + value);
            Thread.sleep(100); // 模拟写操作
            sharedData = value;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock(); // 释放写锁
        }
    }

    public static void main(String[] args) {
        ReadWriteLockExample example = new ReadWriteLockExample();

        Runnable readTask = example::readData;
        Runnable writeTask = () -> example.writeData((int) (Math.random() * 100));

        Thread t1 = new Thread(readTask, "Reader-1");
        Thread t2 = new Thread(readTask, "Reader-2");
        Thread t3 = new Thread(writeTask, "Writer-1");
        Thread t4 = new Thread(writeTask, "Writer-2");

        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

输出示例：

Reader-1 is reading: 0
Reader-2 is reading: 0
Writer-1 is writing: 42
Writer-2 is writing: 87

解释：

多个线程可以同时执行 readData() 方法，但如果有线程执行 writeData()，其他线程会被阻塞。
ReentrantReadWriteLock 确保了读写互斥、读读共享的特性。

2. 写锁优先与读锁优先

ReentrantReadWriteLock 默认是 写锁优先，以避免写线程“饥饿”。可以通过构造方法改变优先级。

示例：创建读锁优先的锁

ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true); // 公平锁，读锁优先

公平模式：线程按等待顺序获取锁，避免写线程长时间等待。
非公平模式（默认）：写线程可能“抢占”锁，性能更高。

内部工作机制

基于 AQS（AbstractQueuedSynchronizer）实现

ReentrantReadWriteLock 使用 AQS 管理读写状态。
读锁计数：通过一个高位记录当前持有读锁的线程数量。
写锁状态：通过低位记录当前是否有线程持有写锁。

锁升级与降级

锁降级
：允许从写锁降级为读锁。
- 先获取写锁，再获取读锁，最后释放写锁。
锁升级：不支持从读锁升级为写锁。

示例：锁降级

lock.writeLock().lock(); // 获取写锁
try {
    // 写操作
    lock.readLock().lock(); // 获取读锁
} finally {
    lock.writeLock().unlock(); // 释放写锁
}
// 此时仍持有读锁
lock.readLock().unlock(); // 最后释放读锁

注意事项与建议

读写分离的适用场景
- 适用于读多写少的场景，例如缓存、配置读取。
- 如果写操作频繁，ReentrantReadWriteLock 的性能可能不如普通的独占锁（如 ReentrantLock）。
避免锁升级
- ReentrantReadWriteLock 不支持从读锁直接升级为写锁，可能导致死锁。
- 如果需要读写转换，应释放读锁后重新获取写锁。
选择公平模式与非公平模式
- 公平模式更公平，但性能稍低。
- 非公平模式适合高并发场景，默认情况下使用非公平锁。
锁降级的正确使用
- 锁降级可以减少锁切换的开销，但需确保降级后的操作仍然是线程安全的。

总结

读写锁的概念：读写锁允许多个线程同时读，但写操作是独占的。
实现原理：基于 AQS 管理读锁和写锁的状态，通过共享锁和独占锁机制实现读写分离。
适用场景：读多写少的场景，如缓存、文件读取、配置管理。
使用建议：注意避免锁升级，合理选择公平与非公平模式，充分利用锁降级特性提升性能。