1、可重入锁（递归锁）

可重入锁是一种技术： 任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞。

可重入锁的原理： 通过组合自定义同步器来实现锁的获取与释放。

• 再次获取锁：识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。获取锁后，进行计数自增
• 释放锁：释放锁时，进行计数自减。

Java中的可重入锁： ReentrantLock、synchronized修饰的方法或代码段。

可重入锁的作用： 避免死锁。

面试题1： 可重入锁如果加了两把，但是只释放了一把会出现什么问题？ 答：程序卡死，线程不能出来，也就是说我们申请了几把锁，就需要释放几把锁。

面试题2： 如果只加了一把锁，释放两次会出现什么问题？ 答：会报错，java.lang.IllegalMonitorStateException

2、读写锁

2.1、读写分离

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

读写锁 通过ReentrantReadWriteLock类来实现 ,只允许读读共存，读写互斥

为了提高性能，Java 提供了读写锁，在读的地方使用读锁，在写的地方使用写锁，灵活控制，如果没有写锁的情况下，读是无阻塞的，在一定程度上提高了程序的执行效率。 读写锁分为读锁 和写锁，多个读锁不互斥，读锁与写锁互斥，这是由 jvm 自己控制的。

读锁： 允许多个线程获取读锁，同时访问同一个资源。

写锁： 只允许一个线程获取写锁，不允许同时访问同一个资源。

举个栗子加深理解：

class MyResource
{Map<String,String> map = new HashMap<>();//=====ReentrantLock 等价于 =====synchronized//Lock lock = new ReentrantLock();//=====ReentrantReadWriteLock 一体两面，读写互斥，读读共享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);//后续开启注释修改为2000，演示一体两面，读写互斥，读读共享，读没有完成时候写锁无法获得//try { TimeUnit.MILLISECONDS.sleep(2000); } 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++) {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();}//暂停几秒钟线程try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }//读全部over才可以继续写for (int i = 1; i <=3; i++) {int finalI = i;new Thread(() -> {myResource.write(finalI +"", finalI +"");},"newWriteThread==="+String.valueOf(i)).start();}}/*** 运行结果:* 3   ---正在写入* 3   ---完成写入* 4   ---正在写入* 4   ---完成写入* 1   ---正在写入* 1   ---完成写入* 2   ---正在写入* 2   ---完成写入* 5   ---正在写入* 5   ---完成写入* 6   ---正在写入* 6   ---完成写入* 7   ---正在写入* 7   ---完成写入* 8   ---正在写入* 8   ---完成写入* 9   ---正在写入* 9   ---完成写入* 10  ---正在写入* 10  ---完成写入* 1   ---正在读取* 1   ---完成读取result：1* 2   ---正在读取* 3   ---正在读取* 5   ---正在读取* 5   ---完成读取result：5* 2   ---完成读取result：2* 10  ---正在读取* 10  ---完成读取result：10* 4   ---正在读取* 8   ---正在读取* 8   ---完成读取result：8* 9   ---正在读取* 9   ---完成读取result：9* 7   ---正在读取* 7   ---完成读取result：7* 6   ---正在读取* 6   ---完成读取result：6* 3   ---完成读取result：3* 4   ---完成读取result：4* newWriteThread===3  ---正在写入* newWriteThread===3  ---完成写入* newWriteThread===2  ---正在写入* newWriteThread===2  ---完成写入* newWriteThread===1  ---正在写入* newWriteThread===1  ---完成写入** Process finished with exit code 0*/
}

2.2、从写锁到读锁，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();}/*** 运行结果:* -------正在写入* -------正在读取** Process finished with exit code 0*/
}

线程获取读锁是不能直接升级为写入锁的，也就是说可以写锁降级为读锁，不可逆

在ReentrantReadWriteLock中，当读锁被使用时，如果有线程尝试获取写锁，该写线程会被阻塞

所以，需要释放所有读锁，才可获取写锁

2.3、写锁和读锁是互斥的

（这里的互斥是指线程间的互斥，当前线程可以获取到写锁又获取到读锁，但是获取到了读锁不能继续获取写锁），这是因为读写锁要保持写操作的可见性。

因为，如果允许读锁在被获取的情况下对写锁的获取，那么正在运行的其他读线程无法感知到当前写线程的操作,可能会出现脏读。

因此，分析读写锁ReentrantReadWriteLock，会发现它有个潜在的问题：

如果有线程正在读，写线程需要等待读线程释放锁后才能获取写锁

即ReadWriteLock读的过程中不允许写，只有等待线程都释放了读锁，当前线程才能获取写锁，

也就是写入必须等待，这是一种悲观的读锁，o(╥﹏╥)o，人家还在读着那，你先别去写，省的数据乱

有没有比读写锁更快的锁？

3、邮戳锁StampedLock

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

3.1、是什么

StampedLock是JDK1.8中新增的一个读写锁，是对JDK1.5中的读写锁ReentrantReadWriteLock的优化

stamp 戳记 ，代表了锁的状态，当stamp返回 0 时 ，表示线程获取锁失败，当释放锁或者转换锁的时候，都要传入最初获取的 stamp 值

3.2、锁饥饿

ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了

假如当前1000个线程，999个读，1个写，有可能999个读取线程长时间抢到了锁，那1个写线程就悲剧了

因为当前有可能会一直存在读锁，而无法获得写锁，根本没机会写，o(╥﹏╥)o

3.3、如何缓解锁饥饿问题呢

3.3.1、使用“公平”策略

使用“公平”策略可以一定程度上缓解锁饥饿问题，但是会牺牲系统吞吐量为代价

new ReentrantReadWriteLock(true)

3.3.2、StampedLock类的乐观锁

• ReentrantReadWriteLock

允许多个线程同时读，但是只允许一个线程写，在线程获取到写锁的时候，其他写操作和读操作都会处于阻塞状态，

读锁和写锁也是互斥的，所以在读的时候是不允许写的，读写锁比传统的synchronized速度要快很多，

原因就是在于ReentrantReadWriteLock支持读并发

• StampedLock横空出世

ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。

但是，StampedLock采取乐观获取锁后，其他线程尝试获取写锁时不会被阻塞，这其实是对读锁的优化，

所以，在获取乐观读锁后，还需要对结果进行校验。

3.4、StampedLock的特点

• 所有获取锁的方法，都返回一个邮戳（Stamp）,Stamp 为0 表示失败，其余都表示成功
• 所有释放锁的方法，都需要一个邮戳（Stamp）,这个Stamp必须和成功获取锁时得到的Stamp 一致
• StampedLock是不可重入的，如果一个线程已经持有了写锁，再去获取写锁的话就会造成死锁

3.5、StampedLock的三种访问模式

• Reading(读模式)：功能和ReentrantReadWriteLock的读锁类似
• Writing(写模式)：功能和ReentrantReadWriteLock的写锁类似
• Optimistic reading （乐观读模式）：无锁机制，类似于数据库中的乐观锁，支持读写并发，很乐观的认为读操作时没有人来修改，假如被修改再升级为悲观锁模式

乐观读模式小栗子：读的过程中允许写锁介入

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);}System.out.println(Thread.currentThread().getName()+"\t finally value: "+number);}//乐观读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(6); } catch (InterruptedException e) { e.printStackTrace(); }new Thread(() -> {resource.write();},"writeThread").start();}/*** 运行过程:* 悲观读情况:* readThread   come in readlock block,4 seconds continue...* readThread   正在读取中......* readThread   正在读取中......* readThread   正在读取中......* readThread   正在读取中......* readThread   获得成员变量值result：37* 写线程没有修改值，因为 stampedLock.readLock()读的时候，不可以写，读写互斥* writeThread =====写线程准备修改* writeThread =====写线程结束修改** 进程已结束,退出代码0* --------------------------------------------------------------------* 乐观读情况:* 4秒前stampedLock.validate值(true无修改，false有修改)  true* readThread   正在读取中......1秒后stampedLock.validate值(true无修改，false有修改) true* readThread   正在读取中......2秒后stampedLock.validate值(true无修改，false有修改) true* readThread   正在读取中......3秒后stampedLock.validate值(true无修改，false有修改) true* readThread   正在读取中......4秒后stampedLock.validate值(true无修改，false有修改) true* readThread   finally value: 37* main最终值37* writeThread =====写线程准备修改* writeThread =====写线程结束修改** 进程已结束,退出代码0*/
}

3.6、StampedLock的缺点

StampedLock不支持重入，没有Re开头

StampedLock的悲观读锁和写锁都不支持条件变量（Condition）

使用StampedLock 一定不要调用中断操作，即不要调用 interrupt()方法

如果需要支持中断功能，一定使用可中断的悲观读锁readLockInterruptibly()和写锁writeLockInterruptibly()