本文接着上文并发-AQS之ReentrantReadWriteLock源码解读（一）继续解读源码

公平锁读写锁加锁解锁

FairSync就两个方法，其他同非公平锁，抽象的非常好 hasQueuedPredecessors()，它检查当前线程的前面是否有等待的线程

static final class FairSync extends Sync {
    private static final long serialVersionUID = -2274990926593161451L;
    final boolean writerShouldBlock() {
        return hasQueuedPredecessors();
    }
    final boolean readerShouldBlock() {
        return hasQueuedPredecessors();
    }
}

// AbstractQueuedSynchronizer
public final boolean hasQueuedPredecessors() {
    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
}

读锁ReadLock

lock() ->sync.acquireShared(1) -> tryAcquireShared(arg) -> readerShouldBlock() lock() ->sync.acquireShared(1) -> tryAcquireShared(arg) -> fullTryAcquireShared(current) -> readerShouldBlock() 其他同非公平锁

写锁WriteLock

lock() ->sync.acquire(1) -> tryAcquire(int arg) -> writerShouldBlock() 其他同非公平锁

其他方法

getReadHoldCount()

方法用于获取当前线程持有的读锁的数量。如果当前线程没有持有读锁，则该方法返回0。 如果当前线程持有一个或多个读锁，则该方法返回持有的读锁数量。 这个方法不会考虑其他线程持有的读锁数量，只返回当前线程持有的读锁数量。

// ReentrantReadWriteLock
public int getReadHoldCount() {
    return sync.getReadHoldCount();
}

// ReentrantReadWriteLock.Sync
final int getReadHoldCount() {
    if (getReadLockCount() == 0)
        return 0;

    Thread current = Thread.currentThread();
    if (firstReader == current)
        return firstReaderHoldCount;

    HoldCounter rh = cachedHoldCounter;
    if (rh != null && rh.tid == getThreadId(current))
        return rh.count;

    int count = readHolds.get().count;
    if (count == 0) readHolds.remove();
    return count;
}

// ReentrantReadWriteLock.Sync
final int getReadLockCount() {
    return sharedCount(getState());
}

getReadLockCount()

用于获取整个锁对象中读锁的数量。 它返回从锁对象创建以来获取的所有读锁的总数，而不仅仅是当前线程持有的读锁数量。 这个方法是用来监控读锁的使用情况，以便在需要时调整并发访问策略。

// ReentrantReadWriteLock.Sync
public int getReadLockCount() {
    return sync.getReadLockCount();
}

getWriteHoldCount()

一个用于获取当前线程持有的写锁数量的方法。 如果当前线程没有持有写锁，则该方法返回0。 如果当前线程持有一个写锁，则该方法返回1。如果当前线程持有多个写锁，则该方法返回持有的写锁数量。

// ReentrantReadWriteLock
public int getWriteHoldCount() {
    return sync.getWriteHoldCount();
}

使用案例

读写锁缓存

    private final Map<String, String> cache = new HashMap<>();
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(false);

    public void put(String key, String value) {
        lock.writeLock().lock();
        try {
            System.out.println("Thread " + Thread.currentThread().getName() + " is writing to cache");
            cache.put(key, value);
            System.out.println("Thread " + Thread.currentThread().getName() + " has written to cache");
        } finally {
            lock.writeLock().unlock();
        }
    }

    public String get(String key) {
        lock.readLock().lock();
        try {
            System.out.println("Thread " + Thread.currentThread().getName() + " is reading from cache");
            return cache.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }

JDK中实现AQS简介

同步工具	与AQS关联	详细介绍
AQS原理讲解	AQS原理介绍	并发-AQS原理讲解
ReentrantLock	使用AQS保存锁重复持有的次数。当一个线程获取锁时，ReentrantLock记录当前获得锁的线程标识，用于检测是否重复获取，以及错误线程试图解锁操作时异常情况的处理。	AQS之Reentrantlonk源码解读
Semaphore	使用AQS同步状态来保存信号量的当前计数。tryRelease会增加计数，acquireShared会减少计数。	Semaphore 源码分析以及AQS共享加解锁
CountDownLatch	在多线程并发执行任务时，有时需要让某些线程等待某些条件达成后再开始执行，这时就可以使用CountDownLatch来实现	CountDownLatch 源码分析
ThreadPoolExecutor	创建线程池中的工作线程worker继承AQS，实现独占资源	参考 并发-AQS之ThreadPoolExecutor源码解读（一）
CyclicBarrier	多个线程等待彼此达到一个共同的屏障点，然后同时继续执行。	并发-AQS之CyclicBarrier源码解读
ReentrantReadWriteLock	可重入读写锁，它允许多个线程同时读取一个共享资源，但只允许一个线程写入该共享资源。	参考 并发-AQS之ReentrantReadWriteLock源码解读（一）