Java并发编程：Java中的读/写锁（可重入锁，完全可重入的ReadWriteLock）

在Java并发编程中，读/写锁（Read/Write Lock）是一种非常有用的锁机制，它允许多个读取线程同时访问共享资源，但在任何时候只允许一个写入线程访问。这提高了并发性能，特别是在读取操作远多于写入操作的情况下。下面我将详细介绍读/写锁的特点和使用方法。

读/写锁（Read/Write Lock）

定义：
读/写锁是一种锁机制，它允许多个读取线程同时访问共享资源，但只允许一个写入线程访问。这样可以提高并发性能，特别是在读取操作远多于写入操作的情况下。

特点：

• 多读共享：允许多个读取线程同时访问共享资源。
• 独占写入：只允许一个写入线程访问共享资源。
• 优先级：通常写入操作具有更高的优先级，以避免写入饥饿。

可重入读/写锁（Reentrant Read/Write Lock）

定义：
ReentrantReadWriteLock是java.util.concurrent.locks包中的一个类，它提供了读/写锁功能，并且支持可重入性。

特点：

• 可重入性：线程可以多次获取自己已经持有的锁。
• 显式获取与释放：线程需要显式地获取和释放锁。
• 公平性选项：可以设置为公平锁或非公平锁。
• 支持中断：等待锁的线程可以响应中断。

示例

下面是一个使用ReentrantReadWriteLock的示例，展示了如何使用读/写锁来保护对共享资源的访问：

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
    private int counter = 0;

    public void read() {
        readLock.lock();
        try {
            System.out.println("Reading: " + counter);
        } finally {
            readLock.unlock();
        }
    }

    public void write(int value) {
        writeLock.lock();
        try {
            counter = value;
            System.out.println("Writing: " + counter);
        } finally {
            writeLock.unlock();
        }
    }

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

        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                example.read();
            }
        });

        Thread threadB = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                example.read();
            }
        });

        Thread threadC = new Thread(() -> {
            example.write(100);
        });

        threadA.start();
        threadB.start();
        threadC.start();

        try {
            threadA.join();
            threadB.join();
            threadC.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

在这个示例中，我们创建了一个ReentrantReadWriteLock对象，并从中获取了读锁和写锁。read方法使用读锁来保护读取操作，允许多个线程同时读取counter变量。write方法使用写锁来保护写入操作，确保同一时间只有一个线程可以修改counter变量。

完全可重入的读/写锁

ReentrantReadWriteLock本身就是一个完全可重入的读/写锁。这意味着一个线程可以多次获取自己已经持有的读锁或写锁，而不会导致死锁。下面是一个示例，演示线程如何多次获取读锁：

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class FullyReentrantReadWriteLockExample {
    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
    private int counter = 0;

    public void readMultipleTimes() {
        readLock.lock();
        try {
            System.out.println("First read: " + counter);
            readLock.lock();
            try {
                System.out.println("Second read: " + counter);
            } finally {
                readLock.unlock(); // 释放第二次获取的锁
            }
        } finally {
            readLock.unlock(); // 释放第一次获取的锁
        }
    }

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

        Thread threadA = new Thread(() -> {
            example.readMultipleTimes();
        });

        threadA.start();

        try {
            threadA.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

在这个示例中，readMultipleTimes方法演示了线程如何多次获取读锁，然后再依次释放这些锁。

总结

• 读/写锁（ReentrantReadWriteLock）是一种非常有用的锁机制，它允许多个读取线程同时访问共享资源，但只允许一个写入线程访问。
• 可重入性：ReentrantReadWriteLock支持可重入性，线程可以多次获取自己已经持有的锁。
• 显式获取与释放：线程需要显式地获取和释放锁。
• 公平性选项：可以根据需要设置为公平锁或非公平锁。
• 支持中断：等待锁的线程可以响应中断。

通过理解和使用这些锁的概念，你可以更有效地控制并发程序中的线程访问共享资源的方式，从而提高程序的稳定性和性能。在实际开发中，还应考虑使用Java并发库提供的高级工具和技术来简化并发编程的复杂性。