ReentrantReadWriteLock

1、ReentrantReadWriteLock

      ReentrantReadWriteLock是Java中的一个可重入读写锁，它提供了对共享数据的读写操作进行并发控制的机制。

2、基本原理

      ReentrantReadWriteLock内部使用了两个同步器类：Sync和FairSync。Sync继承了AQS（AbstractQueuedSynchronizer），它负责实现读写锁的基本功能。FairSync继承了Sync，并添加了公平性的支持。通过使用这两个同步器，ReentrantReadWriteLock实现了对读锁和写锁的分离管理，从而提高了并发性能。

3、优缺点

3.1、优点

       3.1.1、 ReentrantReadWriteLock允许多个线程同时读取共享数据，提高了并发读取的效率。
       3.1.2、具备可重入性，即同一个线程可以多次获取读锁或写锁，而不会发生死锁。
       3.1.3、读锁之间不互斥，读锁与写锁互斥，提供了更细粒度的并发控制。
       3.1.4、 支持公平性设置，可以按照请求的顺序获取读锁或写锁，避免写锁饥饿的情况。

3.2、缺点

       3.2.1、 ReentrantReadWriteLock相对于简单的互斥锁（如synchronized）来说，实现和使用上更为复杂。
       3.2.2、写锁的获取和释放，需要更多的系统开销，因为它需要确保没有其他线程正在读取或写入共享数据。

4、代码示例

      创建了一个名为 `lock` 的ReentrantReadWriteLock对象。在读取共享数据的线程中，我们使用 `lock.readLock().lock()` 方法获取读锁，并在操作完成后使用 `lock.readLock().unlock()` 方法释放读锁。在写入共享数据的线程中，我们使用 `lock.writeLock().lock()` 方法获取写锁，并在操作完成后使用 `lock.writeLock().unlock()` 方法释放写锁。

     ReentrantReadWriteLock允许多个线程同时读取共享数据，但在写入时会互斥，确保数据一致性。这样可以提高并发读取的性能，同时保证写入的安全性。

package com.zgcyyh.juc;

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockExample {
    private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private static String resource = "Hello, World!";

    public static void main(String[] args) {
        Thread readerThread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                readResource();
            }
        });

        Thread readerThread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                readResource();
            }
        });

        Thread readerThread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                readResource();
            }
        });

        Thread writerThread = new Thread(new Runnable() {
            @Override
            public void run() {
                writeResource("Goodbye, World!");
            }
        });

        readerThread1.start();
        readerThread2.start();
        writerThread.start();
        //读取改写后的内容
        readerThread3.start();
    }

    public static void readResource() {
        lock.readLock().lock();
        try {
            // 从共享资源中读取
            System.out.println("Reading resource: " + resource);
            Thread.sleep(1000); // 模拟业务
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

    public static void writeResource(String newValue) {
        lock.writeLock().lock();
        try {
            // 写入共享资源
            System.out.println("Writing resource: " + newValue);
            resource = newValue;
            Thread.sleep(1000); // 模拟业务
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.writeLock().unlock();
        }
    }
}