30.jdk源码阅读之ReentrantReadWriteLock

至真源

于 2024-07-31 10:07:53 发布

阅读量588

点赞数 21

分类专栏： JDK源码文章标签： java 开发语言 android

本文为至真源原创，转载请注明出处，谢谢！

本文链接：https://blog.csdn.net/yunkongbian2616/article/details/140805847

版权

JDK源码专栏收录该内容

30 篇文章 0 订阅

订阅专栏

1.写在前面

在这里插入图片描述
ReentrantReadWriteLock 是 Java 并发包中的一个读写锁实现，它允许多个读线程同时访问共享资源，但在写线程访问时，所有的读线程和其他写线程都会被阻塞。不知道大家在日常工作中这个类使用的多不多，对于它的底层实现有没有思考过，比如下面几个问题大家可以看看日常有没有遇到过？

ReentrantReadWriteLock 的读锁和写锁的区别是什么？
ReentrantReadWriteLock 是如何实现公平性和非公平性的？
ReentrantReadWriteLock 的内部结构是怎样的？
ReentrantReadWriteLock 如何实现重入特性？
ReentrantReadWriteLock 的降级和升级是什么？
什么时候应该使用 ReentrantReadWriteLock 而不是 ReentrantLock？
ReentrantReadWriteLock 的 tryLock 方法有什么作用？
ReentrantReadWriteLock 的写锁和读锁可以同时持有吗？

2. 从使用说起

2.1 基本使用

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class BasicUsage {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private int value;

    public void write(int newValue) {
        lock.writeLock().lock();
        try {
            value = newValue;
        } finally {
            lock.writeLock().unlock();
        }
    }

    public int read() {
        lock.readLock().lock();
        try {
            return value;
        } finally {
            lock.readLock().unlock();
        }
    }

    public static void main(String[] args) {
        BasicUsage example = new BasicUsage();
        // Write operation
        example.write(42);
        // Read operation
        System.out.println("Value: " + example.read());
    }
}

2.2 公平锁和非公平锁

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class FairnessExample {
    private final ReentrantReadWriteLock fairLock = new ReentrantReadWriteLock(true); // 公平锁
    private final ReentrantReadWriteLock unfairLock = new ReentrantReadWriteLock(false); // 非公平锁

    public void useFairLock() {
        fairLock.writeLock().lock();
        try {
            // Critical section
        } finally {
            fairLock.writeLock().unlock();
        }
    }

    public void useUnfairLock() {
        unfairLock.writeLock().lock();
        try {
            // Critical section
        } finally {
            unfairLock.writeLock().unlock();
        }
    }
}

2.3 锁降级

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class LockDowngrade {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private int value;

    public void writeAndDowngrade(int newValue) {
        lock.writeLock().lock();
        try {
            value = newValue;
            lock.readLock().lock(); // 获取读锁
        } finally {
            lock.writeLock().unlock(); // 释放写锁
        }

        try {
            // 现在持有读锁，可以进行读操作
            System.out.println("Value after downgrade: " + value);
        } finally {
            lock.readLock().unlock(); // 释放读锁
        }
    }

    public static void main(String[] args) {
        LockDowngrade example = new LockDowngrade();
        example.writeAndDowngrade(42);
    }
}

2.4 使用 tryLock

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

public class TryLockExample {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private int value;

    public boolean tryWrite(int newValue, long timeout, TimeUnit unit) throws InterruptedException {
        if (lock.writeLock().tryLock(timeout, unit)) {
            try {
                value = newValue;
                return true;
            } finally {
                lock.writeLock().unlock();
            }
        } else {
            return false; // 未能获取写锁
        }
    }

    public boolean tryRead(long timeout, TimeUnit unit) throws InterruptedException {
        if (lock.readLock().tryLock(timeout, unit)) {
            try {
                System.out.println("Value: " + value);
                return true;
            } finally {
                lock.readLock().unlock();
            }
        } else {
            return false; // 未能获取读锁
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TryLockExample example = new TryLockExample();
        if (example.tryWrite(42, 1, TimeUnit.SECONDS)) {
            System.out.println("Write successful");
        } else {
            System.out.println("Failed to acquire write lock");
        }

        if (example.tryRead(1, TimeUnit.SECONDS)) {
            System.out.println("Read successful");
        } else {
            System.out.println("Failed to acquire read lock");
        }
    }
}

2.5 读多写少的场景

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadMostly {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private int value;

    public void write(int newValue) {
        lock.writeLock().lock();
        try {
            value = newValue;
        } finally {
            lock.writeLock().unlock();
        }
    }

    public int read() {
        lock.readLock().lock();
        try {
            return value;
        } finally {
            lock.readLock().unlock();
        }
    }

    public static void main(String[] args) {
        ReadMostly example = new ReadMostly();

        // 模拟多个读线程
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                System.out.println("Read value: " + example.read());
            }).start();
        }

        // 模拟写线程
        new Thread(() -> {
            example.write(42);
            System.out.println("Wrote value: 42");
        }).start();
    }
}

3. 构造方法

3.1 无参构造

public ReentrantReadWriteLock() {
        this(false);
    }

3.2 有惨构造

 public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }

3.2.1 构造函数参数

fair: 一个布尔值，指示锁是否应该是公平的。如果为 true，则锁是公平的；如果为 false，则锁是非公平的。

3.2.2 内部成员

sync: 是一个 AbstractQueuedSynchronizer 的子类，用于实现锁的核心同步机制。根据 fair 参数的值，可以是 FairSync 或 NonfairSync。
readerLock: 是一个 ReadLock 对象，表示读锁。
writerLock: 是一个 WriteLock 对象，表示写锁。

3.2.3 公平锁与非公平锁

公平锁（FairSync）: 公平锁通过内部队列来保证锁的获取顺序，先到达的线程先获取锁，避免线程饥饿。
非公平锁（NonfairSync）: 非公平锁不保证锁的获取顺序，可能会插队获取锁，从而提高吞吐量，但可能导致线程饥饿。

3.2.4 ReentrantReadWriteLock 的内部类

ReentrantReadWriteLock 有两个内部类 ReadLock 和 WriteLock，分别表示读锁和写锁。
ReadLock

public static class ReadLock implements Lock, java.io.Serializable {
    private final Sync sync;

    protected ReadLock(ReentrantReadWriteLock lock) {
        sync = lock.sync;
    }

    public void lock() {
        sync.acquireShared(1);
    }

    public void unlock() {
        sync.releaseShared(1);
    }

    // 其他方法省略
}

ReadLock 的构造函数接受一个 ReentrantReadWriteLock 对象，并从中获取 sync。
lock 方法获取读锁，调用 sync 的 acquireShared 方法。
unlock 方法释放读锁，调用 sync 的 releaseShared 方法。

WriteLock

public static class WriteLock implements Lock, java.io.Serializable {
    private final Sync sync;

    protected WriteLock(ReentrantReadWriteLock lock) {
        sync = lock.sync;
    }

    public void lock() {
        sync.acquire(1);
    }

    public void unlock() {
        sync.release(1);
    }

    // 其他方法省略
}

WriteLock 的构造函数接受一个 ReentrantReadWriteLock 对象，并从中获取 sync。
lock 方法获取写锁，调用 sync 的 acquire 方法。
unlock 方法释放写锁，调用 sync 的 release 方法。

3.2.5 Sync 类

Sync 是 AbstractQueuedSynchronizer 的子类，负责管理锁的状态和队列。根据公平性策略，它有两个实现类：FairSync 和 NonfairSync。
FairSync

static final class FairSync extends Sync {
    protected final boolean tryAcquire(int acquires) {
        // 公平锁的获取逻辑
    }

    protected final int tryAcquireShared(int unused) {
        // 公平锁的共享获取逻辑
    }
}

FairSync 实现了公平锁的获取和释放逻辑。

NonfairSync

static final class NonfairSync extends Sync {
    protected final boolean tryAcquire(int acquires) {
        // 非公平锁的获取逻辑
    }

    protected final int tryAcquireShared(int unused) {
        // 非公平锁的共享获取逻辑
    }
}

NonfairSync 实现了非公平锁的获取和释放逻辑。

4. ReentrantReadWriteLock 的读锁和写锁的区别是什么？

4.1 读锁和写锁的基本区别

读锁 (ReadLock)：允许多个线程同时获取，只要没有线程持有写锁。读锁是共享锁。
写锁 (WriteLock)：是独占锁，只有一个线程可以持有。当一个线程持有写锁时，其他线程的读锁和写锁请求都会被阻塞。

4.2 代码示例

以下是一个简单的例子，展示了读锁和写锁的不同行为。

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockExample {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
    private int value;

    // 写操作：独占锁
    public void write(int newValue) {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " acquired write lock");
            value = newValue;
            try {
                Thread.sleep(1000); // 模拟写操作耗时
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        } finally {
            System.out.println(Thread.currentThread().getName() + " released write lock");
            writeLock.unlock();
        }
    }

    // 读操作：共享锁
    public int read() {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " acquired read lock");
            try {
                Thread.sleep(1000); // 模拟读操作耗时
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return value;
        } finally {
            System.out.println(Thread.currentThread().getName() + " released read lock");
            readLock.unlock();
        }
    }

    public static void main(String[] args) {
        ReadWriteLockExample example = new ReadWriteLockExample();

        // 启动多个读线程
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + " read value: " + example.read());
            }, "ReadThread-" + i).start();
        }

        // 启动一个写线程
        new Thread(() -> {
            example.write(42);
        }, "WriteThread").start();
    }
}

4.2.1 运行结果

ReadThread-0 acquired read lock
ReadThread-1 acquired read lock
ReadThread-2 acquired read lock
WriteThread acquired write lock
ReadThread-0 released read lock
ReadThread-0 read value: 0
ReadThread-1 released read lock
ReadThread-1 read value: 0
ReadThread-2 released read lock
ReadThread-2 read value: 0
WriteThread released write lock

4.2.2 读锁

多个读线程可以同时获取读锁，不会相互阻塞。
在上面的例子中，ReadThread-0、ReadThread-1 和 ReadThread-2 可以同时获取读锁并执行读操作。

4.2.3 写锁

写锁是独占锁，只有一个线程可以持有写锁。
当一个线程持有写锁时，其他线程的读锁和写锁请求都会被阻塞。
在上面的例子中，WriteThread 获取写锁后，所有的读线程和其他写线程都会被阻塞，直到写锁被释放。

4.3 读写锁的互斥关系

当一个线程持有写锁时，其他线程不能获取读锁或写锁。
当一个或多个线程持有读锁时，其他线程不能获取写锁，但可以获取读锁。

4.4 读锁和写锁的使用场景

读锁：适用于读多写少的场景，多个读线程可以同时读取共享资源，提高并发性能。
写锁：适用于需要修改共享资源的场景，确保修改操作的原子性和线程安全。

5. ReentrantReadWriteLock 如何实现重入特性？

ReentrantReadWriteLock 的重入特性是通过内部的计数器和线程记录来实现的。每个锁（读锁和写锁）都有一个计数器，用于记录当前线程持有锁的次数。
以下是一个展示重入特性的代码示例：

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantReadWriteLockExample {
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    private final ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
    private int value;

    // 写操作：独占锁，支持重入
    public void write(int newValue) {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " acquired write lock");
            value = newValue;
            nestedWrite(); // 调用重入方法
        } finally {
            System.out.println(Thread.currentThread().getName() + " released write lock");
            writeLock.unlock();
        }
    }

    // 读操作：共享锁，支持重入
    public int read() {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " acquired read lock");
            nestedRead(); // 调用重入方法
            return value;
        } finally {
            System.out.println(Thread.currentThread().getName() + " released read lock");
            readLock.unlock();
        }
    }

    // 嵌套的写操作，用于演示重入
    private void nestedWrite() {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " re-acquired write lock in nestedWrite");
        } finally {
            writeLock.unlock();
        }
    }

    // 嵌套的读操作，用于演示重入
    private void nestedRead() {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " re-acquired read lock in nestedRead");
        } finally {
            readLock.unlock();
        }
    }

    public static void main(String[] args) {
        ReentrantReadWriteLockExample example = new ReentrantReadWriteLockExample();

        // 启动一个写线程
        new Thread(() -> {
            example.write(42);
        }, "WriteThread").start();

        // 启动一个读线程
        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + " read value: " + example.read());
        }, "ReadThread").start();
    }
}

5.1 运行结果

WriteThread acquired write lock
WriteThread re-acquired write lock in nestedWrite
WriteThread released write lock
ReadThread acquired read lock
ReadThread re-acquired read lock in nestedRead
ReadThread released read lock
ReadThread read value: 42

5.2 代码解析

5.2.1 写锁的重入

在 write 方法中，线程首先获取写锁，然后调用 nestedWrite 方法
在 nestedWrite 方法中，线程再次获取写锁，这就是写锁的重入
由于是同一个线程持有锁，所以不会被阻塞

5.2.2 读锁的重入

在 read 方法中，线程首先获取读锁，然后调用 nestedRead 方法。
在 nestedRead 方法中，线程再次获取读锁，这就是读锁的重入。
由于是同一个线程持有锁，所以不会被阻塞。

5.3 内部实现

5.3.1 计数器

每个锁（读锁和写锁）都有一个计数器，用于记录当前线程持有锁的次数。
当同一个线程再次获取锁时，计数器增加；当线程释放锁时，计数器减少。

5.3.2 线程记录

锁内部会记录当前持有锁的线程。
当一个线程请求锁时，会检查当前持有锁的线程是否是自己，如果是，则允许重入。

系列文章

1.JDK源码阅读之环境搭建

2.JDK源码阅读之目录介绍

3.jdk源码阅读之ArrayList(上)

4.jdk源码阅读之ArrayList(下)

5.jdk源码阅读之HashMap

6.jdk源码阅读之HashMap（下）

7.jdk源码阅读之ConcurrentHashMap(上)

8.jdk源码阅读之ConcurrentHashMap（下）

9.jdk源码阅读之ThreadLocal

10.jdk源码阅读之ReentrantLock

11.jdk源码阅读之CountDownLatch

12.jdk源码阅读之CyclicBarrier

13.jdk源码阅读之Semaphore

14.jdk源码阅读之线程池(上)

15.jdk源码阅读之线程池(下)

16.jdk源码阅读之ArrayBlockingQueue

17.jdk源码阅读之LinkedBlockingQueue

18.jdk源码阅读之CopyOnWriteArrayList

19.jdk源码阅读之FutureTask

20.jdk源码阅读之CompletableFuture

21.jdk源码阅读之AtomicLong

22.jdk源码阅读之Thread(上)

23.jdk源码阅读之Thread(下)

24.jdk源码阅读之ExecutorService

25.jdk源码阅读之Executors

26.jdk源码阅读之ConcurrentLinkedQueue

27.jdk源码阅读之ConcurrentLinkedDeque

28.jdk源码阅读之CopyOnWriteArraySet

29.jdk源码阅读之Exchanger

至真源

关注

21
点赞
踩
8

收藏

觉得还不错? 一键收藏
打赏
0
评论
30.jdk源码阅读之ReentrantReadWriteLock

ReentrantReadWriteLock 是 Java 并发包中的一个读写锁实现，它允许多个读线程同时访问共享资源，但在写线程访问时，所有的读线程和其他写线程都会被阻塞。不知道大家在日常工作中这个类使用的多不多，对于它的底层实现有没有思考过，比如下面几个问题大家可以看看日常有没有遇到过？
复制链接

扫一扫