无锁->独占锁->读写锁->邮戳锁
独占锁ReentrantLock与Synchronized
对于使用 ReentrantLock与Synchronized 这两把锁的同步代码块，无论有多少线程，不论是做的什么操作，进入同步代码块的只有一个线程，那么就会导致程序的性能较差。
关于Synchronized 上一篇已经做了详解，可以查看 多线程进阶学习04------Synchronized详解
ReentrantLock与Synchronized 在使用上还是有很大的区别，接下来我们进行学习
1、定义区别：Lock是java的一个interface接口，而synchronized是Java中的关键字
synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API。synchronized 是依赖于 JVM 实现的，前面我们也讲到了 虚拟机团队在 JDK1.6 为 synchronized 关键字进行了很多优化，但是这些优化都是在虚拟机层面实现的，并没有直接暴露给我们。ReentrantLock 是 JDK 层面实现的（也就是 API 层面，需要 lock() 和 unlock() 方法配合 try/finally 语句块来完成），所以我们可以通过查看它的源代码，来看它是如何实现的。
2、自动释放
ynchronized是由JDK实现的，不需要程序员编写代码去控制加锁和释放；synchronized修饰的代码在执行异常时，jdk会自动释放线程占有的锁，不需要程序员去控制释放锁，因此只要服务器不崩溃不会导致死锁现象发生；但是，当Lock发生异常时，如果程序没有通过unLock()去释放锁，则很可能造成死锁现象，因此Lock一般都是在finally块中释放锁
3、响应中断
Lock可以让等待锁的线程响应中断处理，如tryLock(long time, TimeUnit unit)在参数时间内未获取锁，则立即退出尝试获取锁，去执行else内的代码块。而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够中断，程序员无法控制
ReentrantLock另外提供了一种能够中断等待锁的线程的机制，通过 lock.lockInterruptibly() 来实现这个机制。也就是说正在等待的线程可以选择放弃等待，改为处理其他事情。
4、公平与否
synchronized 和 ReentrantLock 默认是非公平锁
ReentrantLock通过构造方法ReentrantLock(boolean fair)传入boolean 来制定是否是公平的
5、悲观与否
synchronized关键字和Lock的实现类都是悲观锁
6、锁的范围
Lock锁的范围有局限性，仅适用于代码块范围
而synchronized可以锁住代码块、对象实例、类；
7、选择性通知|分组唤醒
synchronized关键字与wait()和notify()/notifyAll()方法相结合可以实现等待/通知机制。在使用notify()/notifyAll()方法进行通知时，被通知的线程是由 JVM 选择的，无法选择性通知
ReentrantLock可实现选择性通知（锁可以绑定多个条件）: 但是需要借助于Condition接口与newCondition()方法。Condition是 JDK1.5 之后才有的，它具有很好的灵活性，比如可以实现多路通知功能也就是在一个Lock对象中可以创建多个Condition实例（即对象监视器），其他线程对象可以注册在指定的Condition中，从而可以有选择性的进行线程通知，在调度线程上更加灵活。 用ReentrantLock类结合Condition实例可以实现“选择性通知” ，这个功能非常重要，而且是 Condition 接口默认提供的。而synchronized关键字就相当于整个 Lock 对象中只有一个Condition实例，所有的线程都注册在它一个身上。如果执行notifyAll()方法的话就会通知所有处于等待状态的线程这样会造成很大的效率问题，而Condition实例的signalAll()方法 只会唤醒注册在该Condition实例中的所有等待线程。
8、可重入锁
从名字上理解，ReenTrantLock的字面意思就是再进入的锁，其实synchronized关键字所使用的锁也是可重入
读写锁ReentrantReadWriteLock
ReentrantReadWriteLock将会对读和写场景进行区分，进一步的降低锁的粒度，以此来提升代码性能。
读写互斥：读的时候不要写、写的时候不要读
一体两面，读写互斥，读读共享，读没有完成时候其它线程写锁无法获得
但是读和读可以共享，多线程可以并发访问，大面积可以容许多个线程来读取
读多写少的时候，读写锁good
一、写锁饥饿问题
ReentrantReadWriteLock实现了读写分离，但是一旦读操作比较多的时候，想要获取写锁就变得比较困难了，假如当前1000个线程，999个读，1个写，有可能999个读取线程长时间抢到了锁，那1个写线程就悲剧了
因为当前有可能会一直存在读锁，而无法获得写锁，根本没机会写
使用“公平"策略可以一定程度上缓解这个问题，但是“公平"策略是以牺牲系统吞吐量为代价的
二、锁降级
锁降级就是指将 写入锁降级为读锁，锁严苛程度增大叫升级，变小叫降级。
1、如果同一个线程持有了写锁，在没有释放写锁的情况下，它还可以继续获得读锁。这就是写锁的降级，降级成为了读锁。
2、规则惯例，先获取写锁，然后获取读锁，再释放写锁的次序。
3、如果释放了写锁，那么就完全转换为读锁。
public static void main(String[] args)
{
ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
//正常 A B两个线程
// A
/*readLock.lock();
System.out.println("----读取");
readLock.unlock();
// B
writeLock.lock();
System.out.println("----写入");
writeLock.unlock();*/
//本例，only one 同一个线程
readLock.lock();
System.out.println("----读取");
readLock.unlock();
writeLock.lock();
System.out.println("----写入");
writeLock.unlock();
}
锁降级就是为了让当前线程感知到数据的变化，目的是保证数据的可见性
比如说有两个线程，a线程持有写锁改动了数据，那么a线程要读取数据的话就要释放写锁，释放了写锁就有可能抢占不到锁，导致数据不安全。如果直接能持有读锁就变相保证了数据安全，且降级为读锁之后，别的读线程就可以同时进行读。
邮戳锁StampedLock
Stamped（戳记，long类型）
代表了锁的状态。当stamp返回零时，表示线程获取锁失败。
并且，当释放锁或者转换锁的时候，都要传入最初获取的stamp值。
ReentrantReadWriteLock的读锁被占用的时候，其他线程尝试获取写锁的时候会被阻塞。
但是，StampedLock采取乐观获取锁后，其他线程尝试获取写锁时不会被阻塞，这其实是对读锁的优化，
所以，在获取乐观读锁后，还需要对结果进行校验。
特点
1、所有获取锁的方法,都返回一个邮戳(Stamp),Stamp为零表示获取失败,其余都表示成功;
2、所有释放锁的方法,都需要一个邮戳(Stamp),这个Stamp必须是和成功获取锁时得到的Stamp一致;
3、StampedLock是不可重入的，没有Re开头。危险(如果一个线程已经持有了写锁,再去获取写锁的话就会造成死锁)
4、StampedLock 的悲观读锁和写锁都不支持条件变量(Condition),这个也需要注意。
5、使用 StampedLock一定不要调用中断操作,即不要调用interrupt()方法
StampedLock有三种访问模式：
1、Reading(读模式悲观) : 功能和ReentrantReadWriteLock的读锁类似
2、Writing(写模式悲观) : 功能和ReentrantReadWriteLock的写锁类似
3、Optimistic reading(乐观读模式) : 无锁机制,类似于数据库中的乐观锁, 支持读写并发,很乐观认为读取时没人修改,假如被修改再实现升级为悲观读模式
a、乐观的阅读。 仅当锁定当前未处于写入模式时,方法tryOptimisticRead()才返回非零戳记。 如果自获得给定标记以来没有在写入模式下获取锁定,则方法validate(long)返回 true。 这种模式可以被认为是读锁的极弱版本,可以随时被作者破坏。 对短的只读代码段使用乐观模式通常可以减少争用并提高吞吐量。 但是,它的使用本质上是脆弱的。
b、乐观读取部分 应该只读取字段并将它们保存在局部变量中,以便以后在验证后使用。 在乐观模式下读取的字段可能非常不一致,因此仅在您熟悉数据表示以检查一致性和/或重复调用方法validate() 例如,在首次读取对象或数组引用,然后访问其中一个字段,元素或方法时,通常需要执行此类步骤。
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;
}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 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("写线程没有修改成功，读锁时候写锁无法介入，传统的读写互斥");
}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 = 0; 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);
}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();
},"readThread").start();
//暂停几秒钟线程
try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
System.out.println(Thread.currentThread().getName()+"\t"+"----come in");
resource.write();
},"writeThread").start();
//暂停几秒钟线程
try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); }
System.out.println(Thread.currentThread().getName()+"\t"+"number:" +number);*/
new Thread(() -> {
resource.tryOptimisticRead();
},"readThread").start();
//暂停2秒钟线程,读过程可以写介入，演示
//try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }
//暂停6秒钟线程
try { TimeUnit.SECONDS.sleep(6); } catch (InterruptedException e) { e.printStackTrace(); }
new Thread(() -> {
System.out.println(Thread.currentThread().getName()+"\t"+"----come in");
resource.write();
},"writeThread").start();
}
}
缺点
1、StampedLock不支持重入，没有Re开头
2、StampedLock的悲观读锁和写锁都不支持条件变量（Condition），这个也需要注意
3、使用StampedLock一定不要调用中断操作，即不要调用interrupt()方法