面试突击：为什么要使用读写锁？它有哪些优势？
一、摘要
在上篇文章中，我们讲到ReentrantLock可以保证了只有一个线程能执行加锁的代码。
但是有些时候，这种保护显的有点过头，比如下面这个方法，它仅仅就是只读取数据，不修改数据，它实际上允许多个线程同时调用的。
public class Counter {
private final Lock lock = new ReentrantLock();
private int count;
public int get() {
// 加锁
lock.lock();
try {
return count;
} finally {
// 释放锁
lock.unlock();
}
}
}
站在程序性能的角度，实际上我们想要的是这样的效果。
- 1.读和读之间不互斥，因为只读操作不会有数据安全问题
- 2.写和写之间互斥，避免一个写操作影响另外一个写操作，引发数据计算错误问题
- 3.读和写之间互斥，避免读操作的时候写操作修改了内容，引发数据脏读问题
总结起来就是，允许多个线程同时读，但只要有一个线程在写，其他线程就必须排队等待。
在 JDK 中有一个读写锁ReadWriteLock，使用它就可以解决这个问题，它可以保证以下两点：
- 1.只允许一个线程写入，其他线程既不能写入也不能读取
- 2.没有写入时，多个线程允许同时读，可以提高程序并发性能
实际上，读写锁ReadWriteLock里面有两个锁实现，一个是读操作相关的锁，称为共享锁，当多个线程同时操作时，不会让多个线程进行排队等待，大大的提升了程序并发读的执行效率；另一个是写操作相关的锁，称为排他锁，当多个线程同时操作时，只允许一个线程写入，其他线程进入排队等待；两者进行组合操作，就可以实现上面的预期效果。
下面我们一起来看看它的基本用法！
二、ReadWriteLock 基本用法
2.1、读和读共享
读和读之间不互斥，当多个线程进行读的时候，不会让多个线程进行排队等待。
我们可以看一个简单的例子！
public class Counter {
private final ReadWriteLock lock = new ReentrantReadWriteLock();
private int count;
public void read() {
// 加读锁
lock.readLock().lock();
try {
String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").format(new Date());
System.out.println(time + " 当前线程：" + Thread.currentThread().getName() + "获得了读锁，count:" + count);
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放读锁
lock.readLock().unlock();
}
}
}
public class MyThreadTest {
public static void main(String[] args) {
Counter counter = new Counter();
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
counter.read();
}
});
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
counter.read();
}
});
threadA.start();
threadB.start();
}
}
看一下运行结果：
2023-10-23 16:12:28:119 当前线程：Thread-0获得了读锁，count:0
2023-10-23 16:12:28:119 当前线程：Thread-1获得了读锁，count:0
从日志时间上可以很清晰的看到，尽管加锁了，并且休眠了 5 秒，但是两个线程还是几乎同时执行try()方法里面的代码，证明了读和读之间是不互斥的，可以显著提高程序的运行效率。
2.2、写和写之间互斥
写和写之间互斥，当多个线程进行写的时候，只允许一个线程写入，其他线程进入排队等待。
我们可以看一个简单的例子！
public class Counter {
private final ReadWriteLock lock = new ReentrantReadWriteLock();
private int count;
public void write() {
// 加写锁
lock.writeLock().lock();
try {
count++;
String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").format(new Date());
System.out.println(time + " 当前线程：" + Thread.currentThread().getName() + "获得了写锁，count:" + count);
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放写锁
lock.writeLock().unlock();
}
}
}
public class MyThreadTest {
public static void main(String[] args) {
Counter counter = new Counter();
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
counter.write();
}
});
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
counter.write();
}
});
threadA.start();
threadB.start();
}
}
看一下运行结果：
2023-10-23 16:29:59:103 当前线程：Thread-0获得了写锁，count:1
2023-10-23 16:30:04:108 当前线程：Thread-1获得了写锁，count:2
从日志时间上可以很清晰的看到，两个线程进行串行执行，证明了写和写之间是互斥的。
2.3、读和写之间互斥
读和写之间互斥，当多个线程交替进行读写的时候，操作上互斥，只有一个线程能进入，其他线程进入排队等待。
我们可以看一个简单的例子！
public class Counter {
private final ReadWriteLock lock = new ReentrantReadWriteLock();
private int count;
public void read() {
// 加读锁
lock.readLock().lock();
try {
String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").format(new Date());
System.out.println(time + " 当前线程：" + Thread.currentThread().getName() + "获得了读锁，count:" + count);
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放读锁
lock.readLock().unlock();
}
}
public void write() {
// 加写锁
lock.writeLock().lock();
try {
count++;
String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS").format(new Date());
System.out.println(time + " 当前线程：" + Thread.currentThread().getName() + "获得了写锁，count:" + count);
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放写锁
lock.writeLock().unlock();
}
}
}
public class MyThreadTest {
public static void main(String[] args) {
Counter counter = new Counter();
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
counter.read();
}
});
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
counter.write();
}
});
threadA.start();
threadB.start();
}
}
看一下运行结果：
2023-10-23 16:36:08:786 当前线程：Thread-0获得了读锁，count:0
2023-10-23 16:36:13:791 当前线程：Thread-1获得了写锁，count:1
从日志时间上可以很清晰的看到，两个线程进行串行执行，证明了读和写之间是互斥的。
三、小结
总结下来，ReadWriteLock有以下特点：
- 允许多个线程在没有写入时同时读取，可以提高读取效率
- 当存在写入情况时，只允许一个线程写入，其他线程进入排队等待
- 适合读多写少的场景
对于同一个数据，有大量线程读取，但仅有少数线程修改，使用ReadWriteLock可以显著的提升程序并发执行效率。
例如，一个论坛的帖子，浏览可以看做读取操作，是非常频繁的，而回复可以看做写入操作，它是不频繁的，这种情况就可以使用ReadWriteLock来实现。
本文主要围绕ReadWriteLock的基本使用做了一次知识总结，如果有不正之处，请多多谅解，并欢迎批评指出。
四、参考
1. https://www.cnblogs.com/xrq730/p/4855631.html
2. https://www.liaoxuefeng.com/wiki/1252599548343744/1306581002092578
腾讯云开发者
