深入探索Java并发库（JUC）中的ReentrantReadWriteLock

// ReentrantReadWriteLock的部分内部类定义
public class ReentrantReadWriteLock
    implements ReadWriteLock, java.io.Serializable {

    // 内部抽象类Sync继承自AbstractQueuedSynchronizer
    abstract static class Sync extends AbstractQueuedSynchronizer {
        // ... 省略其他方法和字段 ...

        // 尝试获取写锁的方法（由WriteLock调用）
        final boolean tryAcquire(int acquires) {
            // ... 省略实现细节 ...
        }

        // 尝试释放写锁的方法（由WriteLock调用）
        final boolean tryRelease(int releases) {
            // ... 省略实现细节 ...
        }

        // 尝试获取读锁的方法（由ReadLock调用）
        final int tryAcquireShared(int acquires) {
            // ... 省略实现细节 ...
        }

        // 尝试释放读锁的方法（由ReadLock调用）
        final boolean tryReleaseShared(int releases) {
            // ... 省略实现细节 ...
        }

        // 判断是否处于读锁状态
        final boolean isHeldExclusively() {
            // ... 省略实现细节 ...
        }
    }

    // 非公平锁的实现类NonfairSync继承自Sync
    static final class NonfairSync extends Sync {
        // ... 省略其他方法和字段 ...
    }

    // 公平锁的实现类FairSync继承自Sync
    static final class FairSync extends Sync {
        // ... 省略其他方法和字段 ...
    }

    // 读锁的实现类ReadLock实现Lock接口
    public static class ReadLock implements Lock, java.io.Serializable {
        // ... 省略其他方法和字段 ...

        // 读锁的lock方法实现
        public void lock() {
            sync.acquireShared(1);
        }

        // 读锁的unlock方法实现
        public void unlock() {
            sync.releaseShared(1);
        }
    }

    // 写锁的实现类WriteLock实现Lock接口
    public static class WriteLock implements Lock, java.io.Serializable {
        // ... 省略其他方法和字段 ...

        // 写锁的lock方法实现
        public void lock() {
            sync.acquire(1);
        }

        // 写锁的unlock方法实现
        public void unlock() {
            sync.release(1);
        }
    }

    // ... 省略其他方法和字段 ...
}

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {

    // 共享资源：一个简单的计数器
    private int counter = 0;

    // 创建一个ReentrantReadWriteLock对象
    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    // 获取读锁
    private final ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();

    // 获取写锁
    private final ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

    // 读操作：增加读计数
    public int readCounter() {
        readLock.lock(); // 加读锁
        try {
            // 模拟读操作的耗时
            Thread.sleep(10);
            return counter;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return -1;
        } finally {
            readLock.unlock(); // 释放读锁
        }
    }

    // 写操作：增加计数器的值
    public void incrementCounter() {
        writeLock.lock(); // 加写锁
        try {
            // 模拟写操作的耗时
            Thread.sleep(10);
            counter++;
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            writeLock.unlock(); // 释放写锁
        }
    }

    // 读线程类
    class ReaderThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("读线程" + Thread.currentThread().getId() + "读取计数器值：" + readCounter());
            }
        }
    }

    // 写线程类
    class WriterThread extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                incrementCounter();
                System.out.println("写线程" + Thread.currentThread().getId() + "增加计数器值");
            }
        }
    }

    // 测试方法
    public static void main(String[] args) {
        ReadWriteLockExample example = new ReadWriteLockExample();

        // 启动多个读线程和写线程
        for (int i = 0; i < 3; i++) {
            new Thread(example.new ReaderThread()).start();
            new Thread(example.new WriterThread()).start();
        }
    }
}