JavaSE 中的18 把锁

Java中的18 把锁

1. 乐观锁和悲观锁

一个共享数据加了悲观锁，那线程每次想操作这个数据前都会假设其他线程也可能会操作这个数据，所以每次操作前都会上锁，这样其他线程想操作这个数据拿不到锁只能阻塞了。
在Java 语言中synchronized 和ReentrantLock 等就是典型的悲观锁，还有一些使用了synchronized
关键字的容器类如Hashtable 等也是悲观锁的应用。
乐观锁操作数据时不会上锁，在更新的时候会判断一下在此期间是否有其他线程去更新这个数据。
乐观锁可以使用版本号机制和CAS 算法实现。在Java 语言中java.util.concurrent.atomic 包下的原子类就是使用CAS 乐观锁实现的。

使用场景

1. 乐观锁适用于写比较少（冲突比较小）的场景，因为不用上锁、释放锁，省去了锁的开销，从而提升了吞吐量;
2. 如果是写多读少的场景，即冲突比较严重，线程间竞争激励，使用乐观锁就是导致线程不断进行重试，这样可能还降低了性能，这种场景下使用悲观锁就比较合适。

2. 独占锁和共享锁

独占锁是指锁一次只能被一个线程所持有。如果一个线程对数据加上排他锁后，那么其他线程不能再对该数据加任何类型的锁。获得独占锁的线程即能读数据又能修改数据。
共享锁是指锁可被多个线程所持有。如果一个线程对数据加上共享锁后，那么其他线程只能对数据再加共享锁，不能加独占锁。获得共享锁的线程只能读数据，不能修改数据。

• JDK 中的synchronized 和java.util.concurrent(JUC)包中Lock 的实现类就是独占锁。
• JDK中ReentrantReadWriteLock 就是一种共享锁。

3. 互斥锁和读写锁

互斥锁是独占锁的一种常规实现，是指某一资源同时只允许一个访问者对其进行访问，具有唯一性和排它性。互斥锁一次只能一个线程拥有互斥锁，其他线程只有等待。
读写锁是共享锁的一种具体实现。读写锁管理一组锁，一个是只读的锁，一个是写锁。

1. 读锁可以在没有写锁的时候被多个线程同时持有，而写锁是独占的。写锁的优先级要高于读锁，一个获得了读锁的线程必须能看到前一个释放的写锁所更新的内容;
2. 读写锁相比于互斥锁并发程度更高，每次只有一个写线程，但是同时可以有多个线程并发读;
3. 在JDK 中定义了一个读写锁的接口：ReadWriteLock，ReentrantReadWriteLock 实现了ReadWriteLock接口

4. 公平锁和非公平锁

公平锁是指多个线程按照申请锁的顺序来获取锁，在java 中可以通过构造函数初始化公平锁。
非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁，在高并发环境下，有可能造成优先级翻转，或者饥饿的状态（某个线程一直得不到锁）。
在java 中synchronized 关键字是非公平锁，ReentrantLock 默认也是非公平锁。

5. 可重入锁

可重入锁又称之为递归锁，是指同一个线程在外层方法获取了锁，在进入内层方法会自动获取锁。
ReentrantLock 是一个可重入锁。Synchronized 也是一个可重入锁。
可重入锁的一个好处是可一定程度避免死锁

6. 自旋锁

自旋锁是指线程在没有获得锁时不是被直接挂起，而是执行一个忙循环，这个忙循环就是所谓的自旋。
自旋锁的目的是为了减少线程被挂起的几率，因为线程的挂起和唤醒也都是耗资源的操作。如果锁被另一个线程占用的时间比较长，即使自旋了之后当前线程还是会被挂起，忙循环就会变成浪费系统资源的操作，反而降低了整体性能。

在JDK1.6 又引入了自适应自旋，这个就比较智能了，自旋时间不再固定，由前一次在同一个锁上的自旋时间以及锁的拥有者的状态来决定。如果虚拟机认为这次自旋也很有可能再次成功那就会次序较多的时间，如果自旋很少成功，那以后可能就直接省略掉自旋过程，避免浪费处理器资源。

7. 分段锁

分段锁是一种锁的设计，并不是具体的一种锁。分段锁设计目的是将锁的粒度进一步细化，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。
在Jdk1.8-语言中CurrentHashMap 底层就用了分段锁，使用Segment，就可以进行并发使用了。

8. 锁升级（无锁|偏向锁|轻量级锁|重量级锁）

1. 无锁
   无锁状态其实就是乐观锁
2. 偏向锁
   Java 偏向锁(Biased Locking)是指它会偏向于第一个访问锁的线程，如果在运行过程中，只有一个线程访问加锁的资源，不存在多线程竞争的情况，那么线程是不需要重复获取锁的，这种情况下，就会给线程加一个偏向锁。
   偏向锁的实现是通过控制对象Mark Word 的标志位来实现的，如果当前是可偏向状态，需要进一步判断对象头存储的线程ID 是否与当前线程ID 一致，如果一致直接进入。
3. 轻量级锁
   当线程竞争变得比较激烈时，偏向锁就会升级为轻量级锁，轻量级锁认为虽然竞争是存在的，但是理想情况下竞争的程度很低，通过自旋方式等待上一个线程释放锁。
4. 重量级锁
   如果线程并发进一步加剧，线程的自旋超过了一定次数，或者一个线程持有锁，一个线程在自旋，又来了第三个线程访问时（反正就是竞争继续加大了），轻量级锁就会膨胀为重量级锁，重量级锁会使除了此时拥有锁的线程以外的线程都阻塞。升级到重量级锁其实就是互斥锁了，一个线程拿到锁，其余线程都会处于阻塞等待状态。重量级锁，它会随着多线程的竞争情况逐渐升级，但不能降级。

在Java 中，synchronized 关键字内部实现原理就是锁升级的过程：无锁–> 偏向锁–> 轻量级锁–> 重量级锁

9. 锁优化技术（锁粗化、锁消除）)

1. 锁优化技术
   锁优化技术包括锁粗化、锁消除
2. 锁粗化
   锁粗化就是将多个同步块的数量减少，并将单个同步块的作用范围扩大，本质上就是将多次上锁、解锁的请求合并为一次同步请求。

private static final Object LOCK = new Object();
	for(int i = 0;i < 100; i++) {
		synchronized(LOCK){
		// do some magic things
		}
	}

经过锁粗化可以变更为

synchronized(LOCK){
	for(int i = 0;i < 100; i++) {
		// do some magic things
	}
}

6、锁消除
锁消除是指虚拟机编译器在运行时检测到了共享数据没有竞争的锁，从而将这些锁进行消除。

public String test(String s1, String s2){
	StringBuffer stringBuffer = new StringBuffer();
	stringBuffer.append(s1);
	stringBuffer.append(s2);
	return stringBuffer.toString();
}

stringBuffer 是局部变量，局部变量是在栈上的，栈是线程私有的，所以就算有多个线程访问test 方法也是线程安全的。但是StringBuffer 是线程安全的类，append 方法是同步方法，但是test 方法本来就是线程安全的，为了提升效率，虚拟机帮我们消除了这些同步锁，这个过程就被称为锁消除。

锁的选择

线程要不要锁住同步资源

• 锁住—悲观锁
• 不锁住—乐观锁

锁住同步资源，线程要不要阻塞

• 阻塞
• 不阻塞：自旋锁和适应性自旋锁

同个线程竞争资源的流程细节有没有区别

• 不锁住资源，多个线程中只有一个能修改资源成功，其它线程会重试—无锁
• 同一个线程执行同步资源时自动获取资源—偏向锁
• 多个线程竞争同步资源时，没有获取资源自旋等待锁释放—轻量级锁
• 多个线程竞争同步资源时，没有获取资源的线程阻塞等待唤醒—重量级锁