java并发-ReentrantReadWriteLock读写锁

介绍

读写锁就是将一个锁拆分为读锁和写锁两个锁。

读写锁的获取规则

• 如果有一个线程已经占用了读锁，则此时其他线程如果要申请读锁，可以申请成功。
• 如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待 释放读锁，因为读写不能同时操作。
• 如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，都必须等待之前的线程 释放写锁，同样也因为读写不能同时，并且两个线程不应该同时写。

总之，要么是一个或多个线程同时有读锁，要么是一个线程有写锁，但是两者不会同 时出现。也可以总结为：读读共享、其他都互斥（写写互斥、读写互斥、写读互斥）。

示例

public class ReadWriteLockDemo {
    private static final ReentrantReadWriteLock reentrantReadWriteLock = new
    ReentrantReadWriteLock(false);
    private static final ReentrantReadWriteLock.ReadLock readLock =
    reentrantReadWriteLock
    .readLock();
    private static final ReentrantReadWriteLock.WriteLock writeLock =
    reentrantReadWriteLock
    .writeLock();
    private static void read() {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "得到读锁，正在读取");
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + "释放读锁");
            readLock.unlock();
        }
    }
    private static void write() {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "得到写锁，正在写入");
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + "释放写锁");
            writeLock.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> read()).start();
        new Thread(() -> read()).start();
        new Thread(() -> write()).start();
        new Thread(() -> write()).start();
    }
}

得到的运行结果

Thread-0得到读锁，正在读取
Thread-1得到读锁，正在读取
Thread-0释放读锁
Thread-1释放读锁
Thread-2得到写锁，正在写入
Thread-2释放写锁
Thread-3得到写锁，正在写入
Thread-3释放写锁

读写锁适用场合:适用于一般场合，ReadWriteLock 适用于 读多写少的情况，合理使用可以进一步提高并发效率。

源码解读

public interface ReadWriteLock {
/**
* Returns the lock used for reading.
*
* @return the lock used for reading.
*/
Lock readLock();
/**
* Returns the lock used for writing.
*
* @return the lock used for writing.
*/
Lock writeLock();
}

ReentrantReadWriteLock核心变量

1. ReaderLock：读锁,实现了Lock接口
2. WriterLock：写锁,也实现了Lock接口
3. Sync：继承自AbstractQueuedSynchronize(AQS),可以为公平锁FairSync 或 非公平锁NonfairSync

ReentrantReadWriteLock相关属性和构造函数

/** 内部提供的读锁 */
private final ReentrantReadWriteLock.ReadLock readerLock;
/** 内部提供的写锁 */
private final ReentrantReadWriteLock.WriteLock writerLock;
/** AQS来实现的同步器 */
final Sync sync;
/**
* Creates a new {@code ReentrantReadWriteLock} with
* 默认创建非公平的读写锁
*/
public ReentrantReadWriteLock() {
    this(false);
}
/**
* Creates a new {@code ReentrantReadWriteLock} with
* the given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantReadWriteLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
readerLock = new ReadLock(this);
writerLock = new WriteLock(this);
}

Sync静态内部类的核心属性

abstract static class Sync extends AbstractQueuedSynchronizer {
// 版本序列号
private static final long serialVersionUID = 6317671515068378041L;
// 高16位为读锁，低16位为写锁
static final int SHARED_SHIFT = 16;
// 读锁单位
static final int SHARED_UNIT = (1 << SHARED_SHIFT);
// 读锁最大数量
static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;
// 写锁最大数量
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
// 本地线程计数器
private transient ThreadLocalHoldCounter readHolds;
// 缓存的计数器
private transient HoldCounter cachedHoldCounter;
// 第一个读线程
private transient Thread firstReader = null;
// 第一个读线程的计数
private transient int firstReaderHoldCount;
}

tryAcquireShared方法

该方法其目的是尝试获取共享锁。

protected final int tryAcquireShared(int unused) {
    for (;;) {
        int c = getState();
        int nextc = c + (1 << 16);
        if (nextc < c) {
            throw new Error("Maximum lock count exceeded");
        }
        if (exclusiveCount(c) != 0 && owner != Thread.currentThread())
            return -1;
        if (compareAndSetState(c, nextc))
            return 1;
    }
}

1. int c = getState();: 获取当前锁的状态值。在共享模式中，这个状态值通常表示持有锁的线程数量或其他相关信息。
2. int nextc = c + (1 << 16);: 计算下一个状态值，这里是将当前状态值增加（左移）16位。在共享模式中，通常用高16位表示持有锁的线程数量。
3. if (nextc < c) { throw new Error("Maximum lock count exceeded"); }: 检查是否超过了最大锁数量，如果超过了，抛出一个错误。这是一个防止溢出的保护措施。
4. if (exclusiveCount(c) != 0 && owner != Thread.currentThread()) return -1;: 检查是否有线程持有独占锁（exclusiveCount? != 0），如果有且不是当前线程，则返回-1表示获取失败。这是因为共享锁和独占锁通常不能同时持有，这里保证了只有在没有独占锁被持有时，才能获取共享锁。
5. if (compareAndSetState(c, nextc)) return 1;: 使用原子操作尝试将状态值更新为nextc。如果成功，表示获取锁成功，返回1。这里使用了 compareAndSetState 方法，该方法通常是一个原子的比较并设置操作，用于确保在并发情况下只有一个线程可以成功修改状态值。

tryAcquire方法

该方法尝试获取独占锁（写锁）

protected final boolean tryAcquire(int acquires) {
    /*
    * Walkthrough:
    * 1. If read count nonzero or write count nonzero
    * and owner is a different thread, fail.
    * 2. If count would saturate, fail. (This can only
    * happen if count is already nonzero.)
    * 3. Otherwise, this thread is eligible for lock if
    * it is either a reentrant acquire or
    * queue policy allows it. If so, update state
    * and set owner.
    */
    Thread current = Thread.currentThread();
    int c = getState(); // 获取当前同步状态

    // 获取独占锁(写锁)的被获取的数量
    int w = exclusiveCount(c);

    if (c != 0) {
        // (Note: if c != 0 and w == 0 then shared count != 0)
        // 1. 如果同步状态不为0，且写状态为0，则表示当前同步状态被读锁获取
        // 2. 或者当前拥有写锁的线程不是当前线程
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;

        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");

        // Reentrant acquire
        setState(c + acquires); // 重入获取锁，更新同步状态
        return true;
    }

    // 如果没有读锁被持有，进入这个分支
    if (writerShouldBlock() || !compareAndSetState(c, c + acquires))
        return false;

    setExclusiveOwnerThread(current); // 设置当前线程为独占锁的拥有者
    return true;
}

解释：

1. Thread current = Thread.currentThread();: 获取当前线程。
2. int c = getState();: 获取当前同步状态。
3. int w = exclusiveCount(c);: 获取独占锁（写锁）的被获取的数量。
4. if (c != 0) { ... }: 如果当前同步状态不为0，表示有读锁或者写锁已经被持有。

• 如果写锁数量为0或者当前拥有写锁的线程不是当前线程，则返回false表示获取锁失败。
• 如果写锁数量不为0且当前拥有写锁的线程是当前线程，表示是重入获取锁。检查是否会超过最大锁数量，如果超过则抛出异常，否则更新同步状态并返回true。

5. 如果当前同步状态为0，表示没有读锁被持有，进入这个分支。

• writerShouldBlock(): 检查是否应该阻塞写锁，根据具体实现。
• compareAndSetState(c, c + acquires): 使用CAS原子操作尝试获取锁。如果获取失败，表示有其他线程同时竞争锁，返回false。
• 如果成功获取锁，设置当前线程为独占锁的拥有者，并返回true。

锁降级

意思就是持住写锁，再获取到读锁。
如下场景：

1. 获取写锁： 线程首先获取了一个写锁，以保护一段临界区或共享资源。
2. 完成写操作： 在写锁的保护下，线程执行了一些修改共享资源的操作。
3. 获取读锁： 在完成写操作后，线程希望保持对共享资源的访问，但此时不再需要写锁的保护了。于是，线程降级锁，将写锁降级为读锁。
4. 释放写锁： 最后，线程释放之前持有的写锁，只保持了读锁。

总结

此文章主要介绍了ReentrantReadWriteLock使用以及相关源码部分；更深刻的去理解读写锁的使用和使用场景。