ReentrantReadWriteLock示例代码简介

1.定义`ReentrantReadWriteLock`和锁

    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
    private String data;
    - `rwLock`：创建一个 `ReentrantReadWriteLock` 实例。
    - `readLock`：获取读锁。
    - `writeLock`：获取写锁。
    - `data`：共享资源，可以是任何数据结构。

2.读取数据

    public String readData() {
        readLock.lock();
        try {
            // 模拟读取操作
            System.out.println(Thread.currentThread().getName() + " is reading data: " + data);
            return data;
        } finally {
            readLock.unlock();
        }
    } 
    - `readLock.lock()`：获取读锁。
    - `try` 块：执行读操作。
    - `finally` 块：确保读锁在任何情况下都能被释放。

3.写入数据

 
    public void writeData(String newData) {
        writeLock.lock();
        try {
            // 模拟写入操作
            System.out.println(Thread.currentThread().getName() + " is writing data: " + newData);
            data = newData;
        } finally {
            writeLock.unlock();
        }
    } 
    - `writeLock.lock()`：获取写锁。
    - `try` 块：执行写操作。
    - `finally` 块：确保写锁在任何情况下都能被释放。

4.处理数据(锁降级)

 
    public void processData() {
        writeLock.lock();
        try {
            // 写操作
            data = "Updated Data";
            System.out.println(Thread.currentThread().getName() + " is writing data: " + data);

            // 降级为读锁
            readLock.lock();
            try {
                // 读操作
                System.out.println(Thread.currentThread().getName() + " is reading data after writing: " + data);
            } finally {
                readLock.unlock();
            }
        } finally {
            writeLock.unlock();
        }
    } 
    - 获取写锁:
      writeLock.lock();
	  
    - 执行写操作:
      data = "Updated Data";
      System.out.println(Thread.currentThread().getName() + " is writing data: " + data);
     
    - 获取读锁:
      readLock.lock();

    -执行读操作:
      System.out.println(Thread.currentThread().getName() + " is reading data after writing: " + data);
     
    -释放读锁:
      readLock.unlock();
  
    -释放写锁:
      writeLock.unlock();
 

5.主方法

public static void main(String[] args) {
	SharedResource resource = new SharedResource();

	// 写线程
	Thread writerThread = new Thread(() -> {
		for (int i = 0; i < 5; i++) {
			resource.writeData("Data " + i);
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}, "WriterThread");

	// 读线程
	Thread readerThread1 = new Thread(() -> {
		for (int i = 0; i < 10; i++) {
			resource.readData();
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}, "ReaderThread1");

	Thread readerThread2 = new Thread(() -> {
		for (int i = 0; i < 10; i++) {
			resource.readData();
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}, "ReaderThread2");

	// 处理数据线程（锁降级）
	Thread processDataThread = new Thread(() -> {
		for (int i = 0; i < 5; i++) {
			resource.processData();
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}, "ProcessDataThread");

	writerThread.start();
	readerThread1.start();
	readerThread2.start();
	processDataThread.start();
} 

-写线程：每隔1秒写入一次数据。
-读线程：每隔0.5秒读取一次数据。
-处理数据线程：每隔2秒执行一次 `processData` 方法，
  展示锁降级的过程。

注意事项

1.锁降级顺序:
   -先获取写锁，
      再获取读锁，最后释放写锁:
     writeLock.lock();
     try {
         // 写操作
         readLock.lock();
         try {
             // 读操作
         } finally {
             readLock.unlock();
         }
     } finally {
         writeLock.unlock();
     }
	 
2.避免锁升级:
   -不能从读锁升级为写锁，
      否则可能导致死锁。
   -正确顺序：先获取写锁，
      再获取读锁，最后释放写锁。

3.公平性选择:
   -公平锁：`new ReentrantReadWriteLock(true)`
         使用公平锁。
   -非公平锁：`new ReentrantReadWriteLock(false)`
     或默认构造函数 `new ReentrantReadWriteLock()`使用非公平锁

4.锁粒度：
   -细粒度锁:将锁的粒度细化，
       提高并发性能。
   -粗粒度锁：适用于锁的粒度较大，
       但可能降低并发性能。