【尚硅谷周阳--JUC并发编程】【第十四章--ReentrantLock、ReentrantReadWriteLock、StampedLock讲解】
一、面试题
- 你知道Java里面有那些锁？
- 你说你用过读写锁，锁饥饿问题是什么？
- 有没有比读写锁更快的锁？
- StampedLock知道吗(邮戳锁/票据锁)
- ReentrantReadWriteLock有锁降级机制，你知道吗？
二、简单聊聊ReentrantReadWriteLock
1、是什么?
1.1、读写锁说明
- ReentrantReadWriteLock读写锁定义为：一个资源能够被读个线程访问，或者被一个写线程访问，但是不能同时存在读写线程。
- 一体两面，读写互斥，读读共享(写的时候不可以读，读的时候不能写)
1.2、演变
- 无锁无序->加锁->读写锁演变复习
- 无锁：资源访问不安全
- ReentrantLock：串行锁，不管是读还是写，每次都是一个线程
- ReadWriteLock(实现类：ReentrantReadWriteLock)：读写互斥，读读可以共享，多线程并发可以访问，大面积可以容许多个线程来读取。适用于读多写少的情况，但是容易造成写锁饥饿问题。需要注意锁降级。
1.3、读写锁意义和特点
- 它只允许读读共存，而读写和写写依然是互斥的，大多实际场景是**“读/读”线程间并不存在互斥关系**，只有“读/写”线程或“写/写”线程间的操作需要互斥的。因此引入ReentrantReadWriteLock。
- 一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但不能同时存在写锁和读锁。也即一个资源可以被多个读操作访问或一个写操作访问，但两者不能同时进行。
- 只有在读多写少情景之下，读写锁才具有较高的性能体现。
2、特点
2.1、优点
- 可重入
- 读写兼顾
2.2、code演示
- 使用ReentrantLock一次只有一个线程执行
class MyResource {
// 资源类，模拟一个简单的缓存
Map<String, String> map = new HashMap<>();
// =========ReentrantLock 等价于 ======synchronized
ReentrantLock lock = new ReentrantLock();
public void write(String key, String value) {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "\t" + "正在写入");
map.put(key, value);
// 暂停几秒
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "\t" + "完成写入");
} finally {
lock.unlock();
}
}
public void read(String key) {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + "\t" + "正在读取");
String result = map.get(key);
// 暂停几秒
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "\t" + "完成读取" + "\t" + result);
} finally {
lock.unlock();
}
}
}
public class ReentrantReadWriteLockDemo {
public static void main(String[] args) {
MyResource myResource = new MyResource();
for (int i = 0; i < 10; i++) {
int finalI = i;
new Thread(() -> {
myResource.write(finalI + "", finalI + "");
}, String.valueOf(i)).start();
}
for (int i = 0; i < 10; i++) {
int finalI = i;
new Thread(() -> {
myResource.read(finalI + "");
}, String.valueOf(i)).start();
}
}
}
- 使用读写锁ReentrantReadWriteLock
class MyResource {
// 资源类，模拟一个简单的缓存
Map<String, String> map = new HashMap<>();
// =========ReentrantReadWriteLock一体两面，读写互斥，读读共享
ReadWriteLock rwLock = new ReentrantReadWriteLock();
public void write(String key, String value) {
rwLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t" + "正在写入");
map.put(key, value);
// 暂停几秒
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "\t" + "完成写入");
} finally {
rwLock.writeLock().unlock();
}
}
public void read(String key) {
rwLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t" + "正在读取");
String result = map.get(key);
// 暂停几秒
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "\t" + "完成读取" + "\t" + result);
} finally {1
rwLock.readLock().unlock();
}
}
}
public class ReentrantReadWriteLockDemo {
public static void main(String[] args) {
MyResource myResource = new MyResource();
for (int i = 0; i < 10; i++) {
int finalI = i;
new Thread(() -> {
myResource.write(finalI + "", finalI + "");
}, String.valueOf(i)).start();
}
for (int i = 0; i < 10; i++) {
int finalI = i;
new Thread(() -> {
myResource.read(finalI + "");
}, String.valueOf(i)).start();
}
}
}
- 读未完成时，写无法获得锁
class MyResource {
// 资源类，模拟一个简单的缓存
Map<String, String> map = new HashMap<>();
// =========ReentrantLock 等价于 ======synchronized
ReentrantLock lock = new ReentrantLock();
// =========ReentrantReadWriteLock一体两面，读写互斥，读读共享
ReadWriteLock rwLock = new ReentrantReadWriteLock();
public void write(String key, String value) {
rwLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t" + "正在写入");
map.put(key, value);
// 暂停几秒
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "\t" + "完成写入");
} finally {
rwLock.writeLock().unlock();
}
}
public void read(String key) {
rwLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "\t" + "正在读取");
String result = map.get(key);
// 暂停几秒
try {
TimeUnit.MILLISECONDS.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "\t" + "完成读取" + "\t" + result);
} finally {
rwLock.readLock().unlock();
}
}
}
public class ReentrantReadWriteLockDemo {
public static void main(String[] args) {
MyResource myResource = new MyResource();
for (int i = 0; i < 10; i++) {
int finalI = i;
new Thread(() -> {
myResource.write(finalI + "", finalI + "");
}, String.valueOf(i)).start();
}
for (int i = 0; i < 10; i++) {
int finalI = i;
new Thread(() -> {
myResource.read(finalI + "");
}, String.valueOf(i)).start();
}
for (int i = 0; i < 3; i++) {
int finalI = i;
new Thread(() -> {
myResource.write(finalI + "", finalI + "");
}, "新写锁" + String.valueOf(i)).start();
}
}
}
2.3、结论
- 一体两面，读写互斥，读读共享，读没有完成时候其他线程写锁无法获得
2.4、从写锁->读锁，ReentrantReadWriteLock锁降级
2.4.1、《Java并发编程的艺术》中关于锁降级的说明
2.4.2、读写锁降级演示
- 可以降级
锁降级是为了让当前线程感知到数据的变化，目的是保证数据可见性
- 案例
- 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁
/**
* 锁降级：遵循获取写锁->在获取读锁->再释放写锁的次序，写锁能够降级成为读锁。
*
* 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁
*
* 读没有完成时候写锁无法获得锁，必须要等着读锁读完之后才有机会
*
* @author 匍匐丶前进
* @since 2024/3/29 16:56
**/
public class LockDownGradingDemo {
public static void main(String[] args) {
ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
// 同一个线程
writeLock.lock();
System.out.println("------写入");
readLock.lock();
System.out.println("------读取");
writeLock.unlock();
System.out.println("------写入完成");
readLock.unlock();
System.out.println("------读取完成");
}
}
- 读没有完成时候写锁无法获得锁，必须要等着读锁读完之后才有机会，读锁无法升级为写锁
/**
* 锁降级：遵循获取写锁->在获取读锁->再释放写锁的次序，写锁能够降级成为读锁。
*
* 如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁
*
* 读没有完成时候写锁无法获得锁，必须要等着读锁读完之后才有机会
*
* @author 匍匐丶前进
* @since 2024/3/29 16:56
**/
public class LockDownGradingDemo {
public static void main(String[] args) {
ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
// 同一个线程
readLock.lock();
System.out.println("------读取");
writeLock.lock();
System.out.println("------写入");
writeLock.unlock();
System.out.println("------写入完成");
readLock.unlock();
System.out.println("------读取完成");
}
}
- 不可以升级
2.4.3、写锁和读锁是互斥的
2.5、读写锁之读写规矩，为什么要锁降级？
- Oracle公司ReentrantReadWriteLock源码总结
锁降级 下面的示例代码摘自ReentrantReadWriteLock源码中：
ReentrantReadWriteLock支持锁降级，遵循按照获取写锁，获取读锁再释放写锁的次序，写锁能够降级为读锁，不支持锁升级
class CachedData {
// 数据
Object data;
// 默认false
volatile boolean cacheValid;
final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
void processCachedData() {
rwl.readLock().lock();
// 查看缓存是否有数据
if (!cacheValid) {
// 在写锁之前必须要先释放读锁
rwl.readLock().unlock();
rwl.writeLock().lock();
try {
// 重新校验状态，因为其他写线程可能在这之前修改了状态(类似双端检索)
if (!cacheValid) {
// 写操作
data = ...
cacheValid = true;
}
// 锁降级-->在释放写锁之前占用读锁(理解为当前线程写完之后，需要获取当前最新data进行后续操作，不希望别其他线程在修改data)
rwl.readLock().lock();
} finally {
// 释放写锁，继续持有读锁
rwl.writeLock().unlock();
}
}
try {
// 完成读后操作
use(data);
} finally {
// 释放读锁
rwl.readLock().unlock();
}
}
}
- 代码中声明了一个Volatile类型的cacheValid变量，保证其可见性。
- 首先获取读锁，如果cache不可用，则释放读锁。获取写锁，在更改数据之前，再检查一次cacheValid的值，然后修改数据，将cacheValid置为true，然后在释放写锁前立刻抢夺获取读锁；此时，cache中数据可用，处理cache中数据，最后释放读锁。这个过程就是一个完整的锁降级的过程，目的是保证数据可见性。
- 总结：一句话，同一个线程自己持有写锁时再去拿读锁，其本质相当于重入
- 如果未被锁降级的步骤，即如果当前的线程C在修改完cache中的数据后，没有获取读锁而是直接释放了写锁，那么假设此时另一个线程D获取了写锁并修改了数据，那么C线程无法感知到数据已被修改，则数据出现错误。
三、StampedLock
- 面试题：有没有比读写锁更快地锁？
1、是什么？
- StampedLock是JDK1.8中新增的一个读写锁，也是对JDK1.5中的读写锁ReentrantReadWriteLock的优化
- 邮戳锁又叫票据锁
- stamp(邮戳，long类型)
代表了锁的状态。当stamp返回零时，表示线程获取锁失败。并且，当释放锁或者转换锁的时候，都要传入最初获取的stamp值
2、锁饥饿问题
2.1、什么是锁饥饿问题？
- ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了，假如当前1000个线程，999个读，1个写，有可能999个读取线程长时间抢到了锁，那1个写线程就悲剧了，因为当前有可能会一直存在读锁，而无法获得写锁，根本没有机会。
2.2、如何解决饥饿问题？
- 使用“公平”策略可以一定程度上缓解这个问题
ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
- 但是“公平”策略是以牺牲系统吞吐量为代价的。
2.3、StampedLock乐观读锁
- ReentrantReadWriteLock,允许多个线程同时读，但是只允许一个线程写，在线程获取到写锁的时候，其他写操作和读操作都会处于阻塞状态。读锁和写锁也是互斥的，所以在读的时候是不允许写的。读写锁比传统的synchronized速度要快很多，原因就是在于ReentrantReadWriteLock支持并发读，读读可以共享。
- ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。但是，StampedLock采用乐观锁获取锁后，其他线程尝试获取写锁时不会被阻塞，这其实是对读锁的优化，所以，在获取乐观锁后，还需要对结果进行校验。
- 一句话：对短的只读代码段，使用乐观模式通常可以减少争用并提高吞吐量。
3、StampedLock的特点
- 所有获取锁的方法，都返回一个邮戳(Stamp)，Stamp为零表示获取失败，其余都表示成功
- 所有释放锁的方法，都需要一个邮戳(Stamp)，这个Stamp必须是和成功获取锁时得到的Stamp一致；
- StampedLock是不可重入的，危险(如果一个线程已经持有了写锁，再去获取写锁的话就会造成死锁)
- StampedLock有三种访问模式
- Reading(读模式悲观)：功能和ReentrantReadWriteLock的读锁类似
- Writing(写模式)：功能呢过和ReentrantReadWriteLock的写锁类似
- Optimistic reading(乐观读模式)：无锁机制，类似于数据库中的乐观锁，支持读写并发，很乐观认为读取时没人修改，假如被修改再实现升级为悲观锁模式。
4、乐观读模式案例
- 读的过程中也允许获取写锁介入
4.1、StampedLock可用作读写锁
public class StampedLockDemo {
// StampedLock = ReentrantReadWriteLock + 读的过程中允许写锁的介入
static int number = 37;
static StampedLock stampedLock = new StampedLock();
public void write() {
// 返回一个流水戳记
long stamp = stampedLock.writeLock();
System.out.println(Thread.currentThread().getName() + "\t" + "写线程准备修改");
try {
number = number + 13;
} finally {
stampedLock.unlockWrite(stamp);
}
System.out.println(Thread.currentThread().getName() + "\t" + "写线程结束修改");
}
// 悲观读，读没有完成时候写锁无法获得锁
public void read() {
long stamp = stampedLock.readLock();
System.out.println(Thread.currentThread().getName() + "\t" + "come in readLock code lock,4 seconds continue...");
for (int i = 0; i < 4; i++) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "\t" + "正在读取中......");
}
try {
int result = number;
System.out.println(Thread.currentThread().getName() + "\t" + "获得成员变量值result：" + result);
System.out.println("写线程没有修改成功，读锁时候写锁无法介入，传统的读写互斥");
} finally {
stampedLock.unlockRead(stamp);
}
}
public static void main(String[] args) {
StampedLockDemo resource = new StampedLockDemo();
new Thread(() -> {
resource.read();
}, "readThread").start();
// 暂停几秒
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
resource.write();
}, "writeThread").start();
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "\t" + "number:" + number);
}
}
4.2、StampedLock支持读的过程中允许写锁的介入
public class StampedLockDemo {
// StampedLock = ReentrantReadWriteLock + 读的过程中允许写锁的介入
static int number = 37;
static StampedLock stampedLock = new StampedLock();
public void write() {
// 返回一个流水戳记
long stamp = stampedLock.writeLock();
System.out.println(Thread.currentThread().getName() + "\t" + "写线程准备修改");
try {
number = number + 13;
} finally {
stampedLock.unlockWrite(stamp);
}
System.out.println(Thread.currentThread().getName() + "\t" + "写线程结束修改");
}
// 乐观读，读的过程中允许获取写锁介入
public void tryOptimisticRead() {
long stamp = stampedLock.tryOptimisticRead();
int result = number;
// 故意间隔四秒，很乐观认为读取中没有其他线程修改过number的值
System.out.println("4秒前stampedLock.validate(stamp)方法值(true无修改，false有修改)" + "\t" + stampedLock.validate(stamp));
for (int i = 0; i < 4; i++) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + "\t" + "正在读取......" + i
+ "秒后stampedLock.validate(stamp)方法值(true无修改，false有修改)" + "\t" + stampedLock.validate(stamp));
}
if (!stampedLock.validate(stamp)) {
System.out.println("有修改过------有写操作");
stamp = stampedLock.readLock();
try {
System.out.println("从乐观读 升级为 悲观读");
result = number;
System.out.println("重新悲观读后result：" + result);
} finally {
stampedLock.unlockRead(stamp);
}
}
System.out.println(Thread.currentThread().getName() + "\t" + "finally vlaue" + result);
}
public static void main(String[] args) {
StampedLockDemo resource = new StampedLockDemo();
new Thread(() -> {
resource.tryOptimisticRead();
}, "readThread").start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "\t" + "------come in");
resource.write();
}, "writeLock").start();
}
}
5、StampedLock的缺点
- StampedLock不支持重入，没有Re开头
- StampedLock的悲观读锁和写锁都不支持条件变量(Condition)，这个也需要注意
- 使用StampedLock一定不要调用中断操作，即不要调用interrupt()方法
415
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
