JUC并发编程第十四篇，StampedLock（邮戳锁）为什么比ReentrantReadWriteLock（读写锁）更快！
一、ReentrantReadWriteLock（读写锁）
1、读写锁存在的意义？
- 读写锁：一个资源能够被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程。
- 它并不是真正意义上的读写分离，它只允许读读共存，而读写和写写依然是互斥的。
- 在大多数场景下，读线程和读线程之间并不存在互斥关系，只有读写、写写之间才需要操作互斥，这就是ReentrantReadWriteLock存在的意义，一个ReentrantReadWriteLock同时只能存在一个写锁，但是可以存在多个读锁，并且不能同时存在写锁和读锁，也即一个资源可以被多个读操作访问或一个写操作访问，但两者不能同时进行。
- 只有在读多写少情境之下，读写锁才具有较高的性能体现。
2、读写锁代码示例
class MyResource {
Map<String,String> map = new HashMap<>();
ReentrantReadWriteLock 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) { e.printStackTrace(); }
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.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName()+"\t"+"---完成读取result： "+result);
}finally {
rwLock.readLock().unlock();
}
}
}
public class ReentrantReadWriteLockDemo {
public static void main(String[] args) {
MyResource myResource = new MyResource();
//十个写线程
for (int i = 1; i <=10; i++) {
//Java 8 之后，在匿名类或 Lambda 表达式中访问的局部变量，如果不是 final 类型的话，编译器自动加上 final 修饰符
int finalI = i;
new Thread(() -> {
myResource.write(finalI +"", finalI +"");
},String.valueOf(i)).start();
}
//十个读线程
for (int i = 1; i <=10; i++) {
int finalI = i;
new Thread(() -> {
myResource.read(finalI +"");
},String.valueOf(i)).start();
}
//测试：再5个写线程
for (int i = 1; i <=5; i++) {
int finalI = i;
new Thread(() -> {
myResource.write(finalI +"", finalI +"");
},"测试"+String.valueOf(i)).start();
}
}
}
输出结果分析
3、读写锁的特点（可重入，读写分离）与锁降级
- 锁降级：官方解释为遵循获取写锁、获取读锁、再释放写锁的次序，写锁能够降级成为读锁，但是读锁是不能直接升级为写入锁的。
- 在ReentrantReadWriteLock中，如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁；但是，当读锁被使用时，如果有线程尝试获取写锁，该写线程会被阻塞，需要释放所有读锁，才可获取写锁。
写锁到读锁流程：
读锁到写锁流程：
- 写锁和读锁是线程间互斥的（当前线程可以获取到写锁又获取到读锁，但是获取到了读锁不能继续获取写锁），因为读写锁要保持写操作的可见性。如果允许读锁在被获取的情况下对写锁的获取，那么正在运行的其他读线程无法感知到当前写线程的操作。
4、锁降级官方示例
-
代码中声明了一个volatile类型的cacheValid变量，保证其可见性。
-
首先获取读锁，如果cache不可用，则释放读锁，获取写锁，在更改数据之前，再检查一次cacheValid的值，然后修改数据，将cacheValid置为true，然后在释放写锁前获取读锁；此时，cache中数据可用，处理cache中数据，最后释放读锁。这个过程就是一个完整的锁降级的过程，目的是保证数据可见性。
-
违背锁降级的步骤
- 如果当前的线程C在修改完cache中的数据后，没有获取读锁而是直接释放了写锁，那么假设此时另一个线程D获取了写锁并修改了数据，那么C线程无法感知到数据已被修改，则数据出现错误。
-
遵循锁降级的步骤
- 线程C在释放写锁之前获取读锁，那么线程D在获取写锁时将被阻塞，直到线程C完成数据处理过程，释放读锁。这样可以保证返回的数据是这次更新的数据，该机制是专门为了缓存设计的。
5、ReentrantReadWriteLock存在问题（锁饥饿）？
- 分析读写锁，发现它存在一个潜在的问题：如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁。
- 也就是说，读写锁读的过程中不允许写，只有等待线程都释放了读锁，当前线程才能获取写锁，也就是写入必须等待，这是一种悲观的读锁。
- 假如当前有1000个线程，999个读，1个写，有可能999个读取线程长时间抢到了锁，那1个写线程迟迟不能获取锁，造成锁饥饿问题。
改进：StampedLock读的过程中也允许获取写锁介入，但是需要额外的方法来判断读的过程中是否有写入，这是一种乐观的读锁。
二、StampedLock（邮戳锁）
1、StampedLock是什么？
- StampedLock是JDK1.8中新增的一个读写锁，是对ReentrantReadWriteLock的进一步优化。
- ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。
- StampedLock采取乐观获取锁后，其他线程尝试获取写锁时不会被阻塞，在获取乐观读锁后，还需要对结果进行校验。
- 它里边有一个Long类型的stamp戳记，代表了锁的状态。当stamp返回零时，表示线程获取锁失败，并且，当释放锁或者转换锁的时候，都要传入最初获取的stamp值。
2、演示StampedLock的特点
悲观读演示
public class StampedLockDemo {
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;
}catch (Exception e){
e.printStackTrace();
}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 block,4 seconds continue...");
//暂停4秒钟线程
for (int i = 0; i <4 ; i++) {
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName()+"\t 正在读取中......");
}
try {
int result = number;
System.out.println(Thread.currentThread().getName()+"\t"+" 获得成员变量值result：" + result);
System.out.println("写线程没有修改值，因为 stampedLock.readLock()读的时候，不可以写，读写互斥");
}catch (Exception e){
e.printStackTrace();
}finally {
stampedLock.unlockRead(stamp);
}
}
public static void main(String[] args) {
StampedLockDemo resource = new StampedLockDemo();
//1 悲观读,和ReentrantReadWriteLock一样
new Thread(() -> {
//悲观读
resource.read();
},"readThread").start();
new Thread(() -> {
resource.write();
},"writeThread").start();
}
}
乐观读演示，成功，中途无修改
public class StampedLockDemo {
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;
}catch (Exception e){
e.printStackTrace();
}finally {
stampedLock.unlockWrite(stamp);
}
System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程结束修改");
}
//乐观读
public void tryOptimisticRead() {
long stamp = stampedLock.tryOptimisticRead();
//先把数据取得一次
int result = number;
//间隔4秒钟，我们很乐观的认为没有其他线程修改过number值，实际情况靠判断。
System.out.println("4秒前stampedLock.validate值(true无修改，false有修改)"+"\t"+stampedLock.validate(stamp));
for (int i = 1; i <=4 ; i++) {
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName()+"\t 正在读取中......"+i+
"秒后stampedLock.validate值(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);
}catch (Exception e){
e.printStackTrace();
}finally {
stampedLock.unlockRead(stamp);
}
}
System.out.println(Thread.currentThread().getName()+"\t finally value: "+result);
}
public static void main(String[] args) {
StampedLockDemo resource = new StampedLockDemo();
//2 乐观读，成功
new Thread(() -> {
//乐观读
resource.tryOptimisticRead();
},"readThread").start();
//6秒钟乐观读取resource.tryOptimisticRead()成功
try { TimeUnit.SECONDS.sleep(6); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
resource.write();
},"writeThread").start();
}
}
乐观读演示，失败，中途被修改
public class StampedLockDemo {
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;
}catch (Exception e){
e.printStackTrace();
}finally {
stampedLock.unlockWrite(stamp);
}
System.out.println(Thread.currentThread().getName()+"\t"+"=====写线程结束修改");
}
//乐观读
public void tryOptimisticRead() {
long stamp = stampedLock.tryOptimisticRead();
//先把数据取得一次
int result = number;
//间隔4秒钟，我们很乐观的认为没有其他线程修改过number值，实际情况靠判断。
System.out.println("4秒前stampedLock.validate值(true无修改，false有修改)"+"\t"+stampedLock.validate(stamp));
for (int i = 1; i <=4 ; i++) {
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName()+"\t 正在读取中......"+i+
"秒后stampedLock.validate值(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);
}catch (Exception e){
e.printStackTrace();
}finally {
stampedLock.unlockRead(stamp);
}
}
System.out.println(Thread.currentThread().getName()+"\t finally value: "+result);
}
public static void main(String[] args) {
StampedLockDemo resource = new StampedLockDemo();
//3 乐观读，失败，重新转为悲观读，重读数据一次
new Thread(() -> {
//乐观读
resource.tryOptimisticRead();
},"readThread").start();
//2秒钟乐观读取resource.tryOptimisticRead()失败
try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
resource.write();
},"writeThread").start();
}
}
3、StampedLock存在的问题？
- StampedLock不支持重入
- StampedLock悲观读锁和写锁都不支持condition（条件变量）
- StampedLock使用中一定不能调用中断操作（interrupt方法）
759
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
