并发编程之ReentrantReadWriteLock详解

目录

ReentrantReadWriteLock介绍

线程进入读锁的前提条件

线程进入写锁的前提条件

ReentrantReadWriteLock三个重要的特性

ReentrantReadWriteLock类

ReentrantReadWriteLock使用读写锁

锁降级

注意事项

ReentrantReadWriteLock结构

?ReentrantReadWriteLock读写状态设计

HoldCounter 计数器

写锁的获取

写锁的释放

读锁的获取

读锁的释放

---

ReentrantReadWriteLock介绍

? ? ? ? ReentrantReadWriteLock是Java中的一个读写锁实现，它允许多个线程同时读取共享资源（读读可以并发），但在写入时只允许一个线程独占（读写，写读，写写互斥）。这个锁支持重入，即同一个线程可以多次获取相同类型的锁。这种锁可以提高读操作的并发性，同时保证写操作的独占性。在读多于写的情况下，读写锁能够提供比排它锁更好的并发性和吞吐量。

线程进入读锁的前提条件

没有其他线程的写锁

没有写请求或者有写请求，但调用线程和持有锁的线程是同一个。

线程进入写锁的前提条件

没有其他线程的读锁

没有其他线程的写锁

ReentrantReadWriteLock三个重要的特性

公平选择性：支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平。

可重入：读锁和写锁都支持线程重入。以读写线程为例：读线程获取读锁后，能够再次获取读锁。写线程在获取写锁之后能够再次获取写锁，同时也可以获取读锁。

锁降级：遵循获取写锁、再获取读锁最后释放写锁的次序，写锁能够降级成为读锁。

---

ReentrantReadWriteLock类

?ReentrantReadWriteLock实现了ReadWriteLock接口

? ? ? ? ? ? ? ? ??

? ? ? ? ReentrantReadWriteLock是可重入的读写锁实现类。在它内部，维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 Writer 线程，读锁可以由多个 Reader 线程同时持有。也就是说，写锁是独占的，读锁是共享的。

ReentrantReadWriteLock使用读写锁

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class SharedData {
    private int data = 0;
    private ReadWriteLock lock = new ReentrantReadWriteLock();

    public int readData() {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " is reading data: " + data);
            return data;
        } finally {
            lock.readLock().unlock();
        }
    }

    public void writeData(int newValue) {
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " is writing data: " + newValue);
            data = newValue;
        } finally {
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
        SharedData sharedData = new SharedData();

        // 创建多个读线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                sharedData.readData();
            }, "ReaderThread-" + i).start();
        }

        // 创建一个写线程
        new Thread(() -> {
            sharedData.writeData(42);
        }, "WriterThread").start();
    }
}

? ? ? ?SharedData 类包含一个整数 data，并使用 ReentrantReadWriteLock 对其进行读写保护。多个读线程（ReaderThread）可以同时访问 readData 方法，而写线程（WriterThread）在调用 writeData 方法时会独占写锁，以确保写入的原子性。多个线程能够同时读取数据，但只有一个线程能够写入新的数据。（ReentrantReadWriteLock适合读多写少的场景）

锁降级

? ? ? ? 在互斥锁中，锁是排他的，即一旦线程获取了写锁，其他线程就不能获取读锁或写锁，直到写锁被释放。而ReentrantReadWriteLock允许降级，即允许一个线程在持有写锁的情况下获取读锁，并最终释放写锁，而保持读锁的持有。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class LockDowngradeExample {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void performWrite() {
        lock.writeLock().lock(); // 获取写锁
        try {
            // 执行写操作
            System.out.println("Performing write operation...");
            
            // 获取读锁（锁降级）
            lock.readLock().lock();
        } finally {
            lock.writeLock().unlock(); // 释放写锁
        }

        try {
            // 执行读操作
            System.out.println("Performing read operation...");
        } finally {
            lock.readLock().unlock(); // 释放读锁
        }
    }

    public static void main(String[] args) {
        LockDowngradeExample example = new LockDowngradeExample();
        example.performWrite();
    }
}

? ? ? ? 在以上代码中，线程首先获取写锁，执行写操作，然后将写锁降级为读锁。在读锁的情况下可以执行读操作，而不会阻塞其他线程获取读锁。这个降级的过程就是锁降级。

注意事项

读锁不支持条件变量。

重入时升级不支持：持有读锁的情况下去获取写锁，会导致获取永久等待。

重入时支持降级： 持有写锁的情况下可以去获取读锁。

---

ReentrantReadWriteLock结构

---

?ReentrantReadWriteLock读写状态设计

? ? ? ?在 ReentrantLock 中，使用 Sync ( 实际是 AQS )的?int?类型的?state?来表示同步状态，表示锁被一个线程重复获取的次数。但是，读写锁 ReentrantReadWriteLock 内部维护着一对读写锁，如果要用一个变量维护多种状态，需要采用“按位切割使用”的方式来维护这个变量，将其切分为两部分：高16为表示读，低16为表示写。

通过位运算确定读锁和写锁的状态：

写状态，等于?S & 0x0000FFFF（将高 16 位全部抹去）。 当写状态加1，等于S+1.

读状态，等于 S >>> 16 (无符号补 0 右移 16 位)。当读状态加1，等于S+（1<<16）,也就是S+0x00010000

根据状态的划分能得出一个推论：S不等于0时，当写状态（S&0x0000FFFF）等于0时，则读状态（S>>>16）大于0，即读锁已被获取。

?exclusiveCount(int c)?静态方法，获得持有写状态的锁的次数。

sharedCount(int c)?静态方法，获得持有读状态的锁的线程数量。不同于写锁，读锁可以同时被多个线程持有。而每个线程持有的读锁支持重入的特性，所以需要对每个线程持有的读锁的数量单独计数，这就需要用到 HoldCounter 计数器。

HoldCounter 计数器

? ? ? ?读锁其实就是一个共享锁。一次共享锁的操作就相当于对HoldCounter 计数器的操作。获取共享锁，则该计数器 + 1，释放共享锁，该计数器 - 1。只有当线程获取共享锁后才能对共享锁进行释放、重入操作。

?HoldCounter是用来记录读锁重入数的对象

ThreadLocalHoldCounter是ThreadLocal变量，记录了当前线程在持有读锁的次数。

---

写锁的获取

? ? ? ? 写锁是一个支持重进入的排它锁。如果当前线程已经获取了写锁，则增加写状态。如果当前线程在获取写锁时，读锁已经被获取（读状态不为0）或者该线程不是已经获取写锁的线程， 则当前线程进入等待状态。写锁的获取是通过重写AQS中的tryAcquire方法实现的。

protected final boolean tryAcquire(int acquires) {
    //当前线程
    Thread current = Thread.currentThread();
    //获取state状态   存在读锁或者写锁，状态就不为0
    int c = getState();
    //获取写锁的重入数
    int w = exclusiveCount(c);
    //当前同步状态state != 0，说明已经有其他线程获取了读锁或写锁
    if (c != 0) {
        // c!=0 && w==0 表示存在读锁
        // 当前存在读锁或者写锁已经被其他写线程获取，则写锁获取失败
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;
        // 超出最大范围  65535
        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");
        //同步state状态
        setState(c + acquires);
        return true;
    }
    // writerShouldBlock有公平与非公平的实现, 非公平返回false，会尝试通过cas加锁
    //c==0 写锁未被任何线程获取，当前线程是否阻塞或者cas尝试获取锁 
    if (writerShouldBlock() ||
        !compareAndSetState(c, c + acquires))
        return false;

    //设置写锁为当前线程所有
    setExclusiveOwnerThread(current);
    return true;

writerShouldBlock写锁是否阻塞实现取决公平与非公平的策略（FairSync和NonfairSync）

? ? ??

写锁的释放

写锁释放通过重写AQS的tryRelease方法实现

protected final boolean tryRelease(int releases) {
    //若锁的持有者不是当前线程，抛出异常
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    int nextc = getState() - releases;
    //当前写状态是否为0，为0则释放写锁
    boolean free = exclusiveCount(nextc) == 0;
    if (free)
        setExclusiveOwnerThread(null);
    setState(nextc);
    return free;

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

读锁的获取

通过重写AQS的tryAcquireShared方法和tryReleaseShared方法。读锁的获取实现方法如下：

protected final int tryAcquireShared(int unused) {
    Thread current = Thread.currentThread();
    int c = getState();
    // 如果写锁已经被获取并且获取写锁的线程不是当前线程，当前线程获取读锁失败返回-1   判断锁降级
    if (exclusiveCount(c) != 0 &&
        getExclusiveOwnerThread() != current)
        return -1;
    //计算出读锁的数量
    int r = sharedCount(c);
    /**
    * 读锁是否阻塞    readerShouldBlock()公平与非公平的实现
    * r < MAX_COUNT： 持有读锁的线程小于最大数（65535）
    *  compareAndSetState(c, c + SHARED_UNIT) cas设置获取读锁线程的数量
    */
    if (!readerShouldBlock() &&
        r < MAX_COUNT &&
        compareAndSetState(c, c + SHARED_UNIT)) {   //当前线程获取读锁
        
        if (r == 0) {  //设置第一个获取读锁的线程
            firstReader = current; 
            firstReaderHoldCount = 1;  //设置第一个获取读锁线程的重入数
        } else if (firstReader == current) { // 表示第一个获取读锁的线程重入
            firstReaderHoldCount++;
        } else { // 非第一个获取读锁的线程
            HoldCounter rh = cachedHoldCounter;
            if (rh == null || rh.tid != getThreadId(current))
                cachedHoldCounter = rh = readHolds.get();
            else if (rh.count == 0)
                readHolds.set(rh);
            rh.count++;  //记录其他获取读锁的线程的重入次数
        }
        return 1;
    }
    // 尝试通过自旋的方式获取读锁,实现了重入逻辑
    return fullTryAcquireShared(current);

?readerShouldBlock读锁是否阻塞实现取决公平与非公平的策略（FairSync和NonfairSync）

? ??

读锁的释放

读锁释放的实现主要通过方法tryReleaseShared：

protected final boolean tryReleaseShared(int unused) {
    Thread current = Thread.currentThread();
    //如果当前线程是第一个获取读锁的线程
    if (firstReader == current) {
        // assert firstReaderHoldCount > 0;
        if (firstReaderHoldCount == 1)
            firstReader = null;
        else
            firstReaderHoldCount--; //重入次数减1
    } else {  //不是第一个获取读锁的线程
        HoldCounter rh = cachedHoldCounter;  
        if (rh == null || rh.tid != getThreadId(current))
            rh = readHolds.get();
        int count = rh.count;
        if (count <= 1) {
            readHolds.remove();
            if (count <= 0)
                throw unmatchedUnlockException();
        }
        --rh.count;  //重入次数减1
    }
    for (;;) {  //cas更新同步状态
        int c = getState();
        int nextc = c - SHARED_UNIT;
        if (compareAndSetState(c, nextc))
            // Releasing the read lock has no effect on readers,
            // but it may allow waiting writers to proceed if
            // both read and write locks are now free.
            return nextc == 0;
    }

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

?本文参考自图灵学院Fox老师笔记！