Java并发-读写锁 ReentrantReadWriteLock

1. ReentrantReadWriteLock 的类结构

ReentrantReadWriteLock 是接口 ReadWriteLock 的子类实现，通过 JDK 的代码可以看出这一实现关系。

public class ReentrantReadWriteLock
        implements ReadWriteLock, java.io.Serializable{}

我们再来看下接口 ReadWriteLock，该接口只定义了两个方法：

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

1.1ReentrantReadWriteLock 的特点

• 性质 1 ：可重入性。
• 性质 2 ：读写分离。读锁是共享锁，写锁是排他锁与数据库的锁类似
• 性质 3 ：可以锁降级，写锁降级为读锁。
  • 线程获取写入锁后可以获取读取锁，然后释放写入锁，这样就从写入锁变成了读取锁，从而实现锁降级的特性。

• 性质 4 ：不可锁升级。
  • 线程获取读锁是不能直接升级为写入锁的。需要释放所有读取锁，才可获取写锁。

 1.2 ReentrantReadWriteLock 读锁共享

场景设计：

• 创建三个线程，线程名称分别为 t1，t2，t3，线程实现方式自行选择；
• 三个线程同时运行获取读锁，读锁成功后打印线程名和获取结果，并沉睡 2000 毫秒，便于观察其他线程是否可共享读锁；
• finally 模块中释放锁并打印线程名和释放结果；
• 运行程序，观察结果。

package cn.itcast.interview;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author: msf
 * @date: 2022/11/27
 */
public class DemoTest {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private int i = 0;

    public String readI() {
        try {
            lock.readLock().lock();
            System.out.println("threadName -> " + Thread.currentThread().getName() + " 占用读锁,i->" + i);
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            System.out.println("报错。");
        } finally {
            System.out.println("threadName -> " + Thread.currentThread().getName() + " 释放读锁,i->" + i);
            lock.readLock().unlock();  // 释放锁
        }
        return i + "";
    }

    public static void main(String[] args) {
        DemoTest demo1 = new DemoTest();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                demo1.readI();
            }
        };
        new Thread(runnable, "t1").start();
        new Thread(runnable, "t2").start();
        new Thread(runnable, "t3").start();
    }
}

结果展示

 结果分析：从结果来看，t1，t2，t3 均在同一时间获取了锁，证明了读锁共享的性质。

1.3 ReentrantReadWriteLock 读写互斥

package cn.itcast.interview;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @author: msf
 * @date: 2022/11/27
 */
public class ReadWriteLock {
    private static ReentrantReadWriteLock RWLock = new ReentrantReadWriteLock();
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            RWLock.readLock().lock();
            try {
                System.out.println("获取读锁");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                RWLock.readLock().unlock();
                System.out.println("释放读锁");
            }
        }).start();
        Thread.sleep(100);
        new Thread(()->{
            try {
                RWLock.writeLock().lock();
                System.out.println("已经获取写锁了");
            }finally {
                RWLock.writeLock().unlock();
                System.out.println("释放写锁");
            }
        }).start();
    }
}

结果展示

 结果解析：验证成功，在线程 t1 沉睡的过程中，写锁 t2 线程无法获取锁，因为锁已经被读操作 t1 线程占据了。