java中ReentrantReadWriteLock简单介绍

上周公司进行一次小型的技术培训，培训中提到了ReentrantReadWriteLock，这里写一下简单的使用介绍。

ReentrantReadWriteLock是JAVA的并发包提供的读写锁，它表示两个锁，一个是读操作相关的锁，称为共享锁，线程访问不会发生阻塞；一个是写相关的锁，称为排他锁，线程之间是互斥访问的。

简单理解就是：如果只做读操作，线程之前是可以并行访问的，如果做写操作，线程之前是互斥访问的，这时候只能进行一个写操作，其他写操作会阻塞，读操作也会阻塞，直到写操作释放了锁。

代码演示：

只做读操作：

public class ReadWriteLockTest {

    public static void main(String[] args) {
        int threadCount = 2;
        ReadTask task = new ReadTask();
        for (int i = 0; i < threadCount; i++) {
            new Thread(() -> {
                task.readData();
            }).start();
        }
    }

}

class ReadTask {
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    private int data;

    public void readData() {
        readWriteLock.readLock().lock();// 获取读锁
        System.out.println(Thread.currentThread().getName() + "开始读取数据了");
        try {
            TimeUnit.MILLISECONDS.sleep(20L);
            System.out.println(Thread.currentThread().getName() + "读取数据data=" + data);
            TimeUnit.MILLISECONDS.sleep(20L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "读取数据结束了");
        readWriteLock.readLock().unlock();// 释放读锁
    }
}

运行结果：

Thread-1开始读取数据了
Thread-0开始读取数据了
Thread-0读取数据data=0
Thread-1读取数据data=0
Thread-1读取数据结束了
Thread-0读取数据结束了

可以看到只做读操作，线程是并行执行的，没有发生阻塞现象。

只做写操作：

public class ReadWriteLockTest {

    public static void main(String[] args) {
        int threadCount = 3;
        WriteTask task = new WriteTask();
        for (int i = 0; i < threadCount; i++) {
            int data = threadCount + i;
            new Thread(() -> {
                task.writeData(data);
            }).start();
        }
    }

}

class WriteTask {
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    private int data;

    public void writeData(int data) {
        readWriteLock.writeLock().lock();// 获取写锁
        System.out.println(Thread.currentThread().getName() + "开始写数据了");
        try {
            TimeUnit.MILLISECONDS.sleep(20L);
            System.out.println(Thread.currentThread().getName() + "写入数据data=" + this.data);
            TimeUnit.MILLISECONDS.sleep(20L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "写入数据结束了");
        readWriteLock.writeLock().unlock();// 释放写锁
    }
}

运行结果：

Thread-2开始写数据了
Thread-2写入数据data=0
Thread-2写入数据结束了
Thread-1开始写数据了
Thread-1写入数据data=0
Thread-1写入数据结束了
Thread-0开始写数据了
Thread-0写入数据data=0
Thread-0写入数据结束了

可以看做，线程是互斥执行的，总是一个线程释放写锁以后，下一个获取到写锁的线程才能执行，没有获取的则阻塞等待。

既做读操作也做写操作：

public class ReadWriteLockTest {

    public static void main(String[] args) {
        int threadCount = 1;
        ReadWriteTask task = new ReadWriteTask();
        for (int i = 0; i < threadCount; i++) {
            int data = threadCount + i;
            new Thread(() -> {
                task.readData(); // 读操作
            }).start();
            new Thread(() -> {
                task.readData(); // 读操作
            }).start();
            new Thread(() -> {
                task.writeData(data); // 写操作
            }).start();
            new Thread(() -> {
                task.readData(); // 读操作
            }).start();
            new Thread(() -> {
                task.readData(); // 读操作
            }).start();
        }
    }

}

class ReadWriteTask {
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    private int data;

    public void writeData(int data) {
        readWriteLock.writeLock().lock();// 获取写锁
        System.out.println(
            "==============Time:" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + " "
                + Thread.currentThread().getName() + "开始写入数据==============");
        this.data = data;
        try {
            TimeUnit.MILLISECONDS.sleep(2000L); // 延迟2s
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(
            "==============Time:" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + " "
                + Thread.currentThread().getName() + "写入数据data=" + this.data + "完成========");
        readWriteLock.writeLock().unlock();// 释放写锁
    }

    public void readData() {
        readWriteLock.readLock().lock();// 获取读锁
        System.out.println("Time:" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
            + " " + Thread.currentThread().getName() + "读取数据data=" + data);
        readWriteLock.readLock().unlock();// 释放读锁
    }
}

运行结果：

Time:2020-06-02 14:19:00 Thread-1读取数据data=0
Time:2020-06-02 14:19:00 Thread-0读取数据data=0
==============Time:2020-06-02 14:19:00 Thread-2开始写入数据==============
==============Time:2020-06-02 14:19:02 Thread-2写入数据data=1完成========
Time:2020-06-02 14:19:02 Thread-3读取数据data=1
Time:2020-06-02 14:19:02 Thread-4读取数据data=1

可以看到，前两个线程读操作是几乎同时进行的，当进行写操作时，此时读操作线程进入阻塞状态，当写操作完成以后，读操作线程又可以同时运行了。这也说明了读操作的锁是共享锁，写操作的锁是排他锁。