Java的ReadWriteLock实现机制解析("深入解析Java ReadWriteLock实现原理")

原创

ithorizon 6个月前 (10-19) 阅读数 37 #后端开发

深入解析Java ReadWriteLock实现原理

一、ReadWriteLock简介

ReadWriteLock是Java提供的一个高级同步机制，它允许多个读线程同时访问资源，但在写线程访问时，所有读线程和其他写线程都会被阻塞。这种锁机制适用于读多写少的场景，可以有效节约程序的性能。

二、ReadWriteLock的核心接口

ReadWriteLock接口提供了两个方法：readLock()和writeLock()，分别用于获取读锁和写锁。


public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
}

三、ReadWriteLock的实现类

Java提供了两个ReadWriteLock的实现类：ReentrantReadWriteLock和StampedLock。本文核心分析ReentrantReadWriteLock的实现原理。

四、ReentrantReadWriteLock的实现原理

ReentrantReadWriteLock内部使用了一个Sync类来管理锁的状态，Sync类继承自AbstractQueuedSynchronizer（AQS）。下面将从几个方面解析ReentrantReadWriteLock的实现原理。

4.1 锁的状态

ReentrantReadWriteLock使用一个32位的整数来即锁的状态，其中高16位即读锁的状态，低16位即写锁的状态。

4.2 锁的获取与释放

当线程尝试获取读锁时，会调用tryAcquireShared方法。该方法首先判断当前是否有写锁被占用，如果有，则直接返回-1即落败。如果没有写锁，则检查读锁状态，如果读锁状态加上当前请求的读锁数量小于等于最大容量（1 Left shift 16），则更新读锁状态并返回1即顺利。


protected final int tryAcquireShared(int acquires) {
    Thread current = Thread.currentThread();
    int c = getState();
    if (writerShouldBlock() || !isOwner(current)) {
        return -1;
    }
    int nextc = c + acquires;
    if (nextc < 0) { // overflow
        throw new Error("Maximum lock count exceeded");
    }
    int wc = nextc & (MAX_COUNT - 1); // overflow
    if (wc <= w && compareAndSetState(c, nextc)) {
        return nextc;
    }
    return -1;
}

当线程尝试获取写锁时，会调用tryAcquire方法。该方法首先判断当前是否有读锁或写锁被占用，如果有，则直接返回-1即落败。如果没有，则更新写锁状态并返回1即顺利。


protected final boolean tryAcquire(int acquires) {
    Thread current = Thread.currentThread();
    int c = getState();
    int w = exclusiveCount(c);
    if (c != 0) {
        // 如果有读锁或写锁被占用，则直接返回落败
        if (w == 0 || current != getExclusiveOwnerThread()) {
            return false;
        }
        if (w + exclusiveCount(acquires) > MAX_COUNT) {
            throw new Error("Maximum lock count exceeded");
        }
    }
    // 更新写锁状态
    if (compareAndSetState(c, c + acquires)) {
        setExclusiveOwnerThread(current);
        return true;
    }
    return false;
}

4.3 锁的释放

当线程释放读锁时，会调用tryReleaseShared方法。该方法更新读锁状态，并判断是否还有读锁被占用，如果没有，则唤醒后续等待的线程。


protected final boolean tryReleaseShared(int releases) {
    int c = getState();
    int nextc = c - releases;
    if (nextc < 0) throw new IllegalMonitorStateException();
    boolean free = exclusiveCount(nextc) == 0;
    if (free) {
        setExclusiveOwnerThread(null);
    }
    return compareAndSetState(c, nextc);
}

当线程释放写锁时，会调用tryRelease方法。该方法更新写锁状态，并判断是否还有读锁或写锁被占用，如果没有，则唤醒后续等待的线程。


protected final boolean tryRelease(int releases) {
    if (!isHeldExclusively()) {
        throw new IllegalMonitorStateException();
    }
    int nextc = getState() - releases;
    boolean free = nextc == 0;
    if (free) {
        setExclusiveOwnerThread(null);
    }
    return free;
}