无锁→独占锁→读写锁→邮戳锁

1. 关于锁的大厂面试题

你知道Java里面有哪些锁?
你说你用过读写锁，锁饥饿问题是什么？
有没有比读写锁更快的锁？
StampedLock知道吗?(邮戳锁/票据锁)
ReentrantReadWriteLock有锁降级机制策略你知道吗？

2. 读写锁

读写锁定义为一个资源能够被多个读线程访问，或者被一个写线程访问，但是不能同时存在读写线程。

2.1 ReentrantReadWriteLock分析

由ReentrantLock与ReentrantReadWriteLock的对比

ReentrantLock实现的是Lock接口
ReentrantReadWriteLock实现的是ReadWriteLock接口

ReadWriteLock接口

有一个读锁一个写锁

2. 读写锁演变

无锁无序->加锁->读写锁

无锁时期一旦多线程,肯定会出现线程安全问题
加锁时期读读操作也只能单线程操作-----解决了线程安全问题但是性能太低
读写锁时期:高并发的情况下大部分的请求都是查询请求,即读多写少的情况,如果读读也互斥了那么效率极低,而且读操作不会影响数据一致性可以不互斥—读写锁诞生.
- 缺点:
  1. 因为读写锁读写互斥,假设100个线程99个都是读线程只有一个写线程,写线程很难抢到机会,就会出现锁饥饿问题
  2. 锁降级:为了让当前线程感知到数据的变化，目的是保证数据可见性,写锁会降级为写锁(写后立刻读)

2.3 『读写锁』意义和特点

『读写锁ReentrantReadWriteLock』并不是真正意义上的读写分离，它只允许读读共存，而读写和写写依然是互斥的，
大多实际场景是“读/读”线程间并不存在互斥关系，只有"读/写"线程或"写/写"线程间的操作需要互斥的。因此引入ReentrantReadWriteLock。
一个ReentrantReadWriteLock同时只能存在一个写锁但是可以存在多个读锁，但不能同时存在写锁和读锁
- 也即一个资源可以被多个读操作访问或一个写操作访问，但两者不能同时进行。
只有在读多写少情境之下，读写锁才具有较高的性能体现。

2.4 ReentrantLock加锁实例

package site.zhourui.readWriteLockAndStampedLock;import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class MyResource {Map<String,String> map = new HashMap<>();//=====ReentrantLock 等价于 =====synchronizedLock lock = new ReentrantLock();//=====ReentrantReadWriteLock 一体两面，读写互斥，读读共享ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();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) { e.printStackTrace(); }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);//后续开启注释修改为2000，演示一体两面，读写互斥，读读共享，读没有完成时候写锁无法获得try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }System.out.println(Thread.currentThread().getName()+"\t"+"---完成读取result："+result);}finally {lock.unlock();}}}public class ReadWriteLockDemo {public static void main(String[] args){MyResource myResource = new MyResource();for (int i = 1; i <=10; i++) {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();}}
}

执行结果:

不光读写互斥,读读也是互斥的

2.5 ReentrantReadWriteLock实例实现读读共享

只需要把ReentrantLock换成对应的读写锁

执行结果:

读写仍然互斥,但是读读不会互斥了

2.5.1 读锁占用时写锁是无法获取的

将读锁sleep参数修改为2000

在执行10个读线程后再次写线程

执行结果:

在读锁没有释放的时,写锁是不能获取的

2.6 读写锁的锁降级

从写锁→读锁，ReentrantReadWriteLock可以降级

锁降级：将写入锁降级为读锁(类似Linux文件读写权限理解，就像写权限要高于读权限一样)

2.6.1 读写锁降级规则

锁降级：遵循获取写锁→再获取读锁→再释放写锁的次序，写锁能够降级成为读锁。
如果一个线程占有了写锁，在不释放写锁的情况下，它还能占有读锁，即写锁降级为读锁。

2.6.2 读写锁降级的作用

锁降级是为了让当前线程感知到数据的变化，目的是保证数据可见性

2.6.3 代码实例

package site.zhourui.readWriteLockAndStampedLock;import java.util.concurrent.locks.ReentrantReadWriteLock;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();}}

执行结果：

当,当前线程没有释放写锁时,仍然能够该线程仍然能够获取写锁:锁降级

注意之前的读写互斥是说的多线程之间,这里是一个线程的情况获取写锁还能获取读锁这叫锁降级

2.7 锁不可升级

如果有线程在读，那么写线程是无法获取写锁的，是悲观锁的策略

2.8 总结

写锁和读锁是互斥的（这里的互斥是指线程间的互斥，当前线程可以获取到写锁又获取到读锁，但是获取到了读锁不能继续获取写锁），这是因为读写锁要保持写操作的可见性。
因为，如果允许读锁在被获取的情况下对写锁的获取，那么正在运行的其他读线程无法感知到当前写线程的操作。

因此，
分析读写锁ReentrantReadWriteLock，会发现它有个潜在的问题：读锁全完，写锁有望；写锁独占，读写全堵；
如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁，见前面Case《code演示LockDownGradingDemo》即ReadWriteLock读的过程中不允许写，只有等待线程都释放了读锁，当前线程才能获取写锁，也就是写入必须等待，这是一种悲观的读锁，o(╥﹏╥)o，人家还在读着那，你先别去写，省的数据乱。

2.9 Oracle公司ReentrantWriteReadLock源码总结

锁降级下面的示例代码摘自ReentrantWriteReadLock源码中：
ReentrantWriteReadLock支持锁降级，遵循按照获取写锁，获取读锁再释放写锁的次序，写锁能够降级成为读锁，不支持锁升级。
解读在最下面:

3. 邮戳锁StampedLock 也叫票据锁

StampedLock是JDK1.8中新增的一个读写锁，也是对JDK1.5中的读写锁ReentrantReadWriteLock的优化。
stamp（戳记，long类型）
- 代表了锁的状态。当stamp返回零时，表示线程获取锁失败。并且，当释放锁或者转换锁的时候，都要传入最初获取的stamp值。
它是由锁饥饿问题引出

3.1 锁饥饿问题

ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了，假如当前1000个线程，999个读，1个写，有可能999个读取线程长时间抢到了锁，那1个写线程就悲剧了因为当前有可能会一直存在读锁，而无法获得写锁，根本没机会写

3.1.1 如何缓解锁饥饿问题？

使用“公平”策略可以一定程度上缓解这个问题
- 但是“公平”策略是以牺牲系统吞吐量为代价的
邮戳锁
- 乐观读来解决问题

3.2 StampedLock 和ReentrantReadWriteLock的区别

ReentrantReadWriteLock

允许多个线程同时读，但是只允许一个线程写，在线程获取到写锁的时候，其他写操作和读操作都会处于阻塞状态，
读锁和写锁也是互斥的，所以在读的时候是不允许写的，读写锁比传统的synchronized速度要快很多，
原因就是在于ReentrantReadWriteLock支持读并发
StampedLock

ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。
但是，StampedLock采取乐观获取锁后，其他线程尝试获取写锁时不会被阻塞，这其实是对读锁的优化，
所以，在获取乐观读锁后，还需要对结果进行校验。

3.3 StampedLock的特点

所有获取锁的方法，都返回一个邮戳（Stamp），Stamp为零表示获取失败，其余都表示成功；
所有释放锁的方法，都需要一个邮戳（Stamp），这个Stamp必须是和成功获取锁时得到的Stamp一致；
StampedLock是不可重入的，危险(如果一个线程已经持有了写锁，再去获取写锁的话就会造成死锁)
StampedLock有三种访问模式
- ①Reading（读模式）：功能和ReentrantReadWriteLock的读锁类似
- ②Writing（写模式）：功能和ReentrantReadWriteLock的写锁类似
- ③Optimistic reading（乐观读模式）：无锁机制，类似于数据库中的乐观锁，支持读写并发，很乐观认为读取时没人修改，假如被修改再实现升级为悲观读模式

3.4 示例

3.4.1 传统读写功能

package site.zhourui.readWriteLockAndStampedLock;import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.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...");//暂停几秒钟线程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();new Thread(() -> {resource.read();},"readThread").start();new Thread(() -> {resource.write();},"writeThread").start();}}

执行结果:

读完再写,实现了读(悲观读)写锁的功能

3.4.2 乐观读写功能

package site.zhourui.readWriteLockAndStampedLock;import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.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...");//暂停几秒钟线程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 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();new Thread(() -> {
//            resource.read();resource.tryOptimisticRead();},"readThread").start();// 2秒钟时乐观读失败，6秒钟乐观读取成功resource.tryOptimisticRead();，修改切换演示try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {resource.write();},"writeThread").start();}
}