本篇文章将介绍常见的锁策略以及CAS中的ABA问题，前面介绍使用synchronized关键字来保证线程的安全性，本质上就是对对象进行加锁操作，synchronized所加的锁到底是什么类型的锁呢？本文带你一探究竟。
🍀1.常见的锁策略
🍂1.1乐观锁与悲观锁
乐观锁与悲观锁是从处理锁冲突的态度方面来进行考量分类的。
- 乐观锁预期锁冲突的概率很低，所以做的准备工作更少，付出更少，效率较高。
- 悲观锁预期锁冲突的概率很高，所以做的准备工作更多，付出更多，效率较低。
🍂1.2读写锁与普通互斥锁
对于普通的互斥锁只有两个操作：
- 加锁
- 解锁
而对于读写锁来说有三个操作：
- 加读锁，如果代码仅进行读操作，就加读锁。
- 加写锁，如果代码含有写操作，就加写锁。
- 解锁。
针对读锁与读锁之间，是没有互斥关系的，因为多线程中同时读一个变量是线程安全的，针对读锁与写锁之间以及写锁与写锁之间，是存在互斥关系的。
在java中有读写锁的标准类，位于java.util.concurrent.locks.ReentrantReadWriteLock，其中ReentrantReadWriteLock.ReadLock为读锁，ReentrantReadWriteLock.WriteLock为写锁。
🍂1.3重量级锁与轻量级锁
这两种类型的锁与悲观锁乐观锁有一定的重叠，重量级锁做的事情更多，开销更大，轻量级锁做的事情较少，开销也就较少，在大部分情况下，可以将重量级锁视为悲观锁，轻量级锁视为乐观锁。
如果锁的底层是基于内核态实现的（比如调用了操作系统提供的mutex接口）此时一般认为是重量级锁，如果是纯用户态实现的，一般认为是轻量级锁。
🍂1.4挂起等待锁与自旋锁
挂起等待锁表示当获取锁失败之后，对应的线程就要在内核中挂起等待(放弃CPU,进入等待队列)，需要在锁被释放之后由操作系统唤醒，该类型的锁是重量级锁的典型实现。 自旋锁表示在获取锁失败后，不会立刻放弃CPU，而是快速频繁的再次询问锁的持有状态一旦锁被释放了，就能立刻获取到锁，该类型的锁是轻量级锁的典型实现。
🍄挂起等待锁与自旋锁的区别
- 最明显的区别就是，挂起等待锁开销比自旋锁要大，且挂起等待锁效率不如自旋锁。
- 挂起等待锁会放弃CPU资源，自旋锁不会放弃CPU资源，会一直等到锁释放为止。
- 自旋锁相较于挂起等待锁更能及时获取到刚释放的锁。
- 自旋锁相较于挂起等待锁的劣势就是当自旋的时间长了，会持续地销耗CPU资源，因此自旋锁也可以说是乐观锁。
🍂1.5公平锁与非公平锁
公平锁遵循先来后到的原则，多个线程在等待一把锁的时候，谁先来尝试拿锁，那这把锁就是谁的。 非公平锁遵循随机的原则，多个线程正在等待一把锁时，当锁释放时，每个线程获取到这把锁的概率是均等的。
🍂1.6可重入锁与不可重入锁
一个线程连续加锁两次，不会造成死锁，那么这个锁就是可重入锁。 反之，一个线程连续加锁两次，会造成死锁现象，那么这个锁就是不可重入锁。
关于死锁是什么，稍等片刻，后面就会介绍到。
🍄综合上述的几种锁策略，synchronized加的所到底是什么锁？
- 它既是乐观锁也是悲观锁，当锁竞争较小时它就是乐观锁，锁竞争较大时它就是悲观锁。
- 它是普通互斥锁。
- 它既是轻量级锁也是重量级锁，根据锁竞争激烈程度自适应。
- 轻量级锁部分基于自旋锁实现，重量级锁部分基于挂起等待锁实现。
- 它是非公平锁。
- 它是可重入锁。
🍂1.7死锁问题
🍁1.7.1常见死锁的情况
死锁是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。
🍄情况1：一个线程一把锁 比如下面这种情况
加锁 方法 () {
加锁 (this) {
//代码块
}
}首先，首次加锁，可以成功，因为当前对象并没有被加锁，然后进去方法里面，再次进行加锁，此时由于当前对象已经被锁占用，所以会加锁失败然后尝试再次加锁，此时就会陷入一个加锁的死循环当中，造成死锁。
🍄情况2：两个线程两把锁 不妨将两个线程称为A,B，两把锁称为S1,S2，当线程A已经占用了锁S1，线程B已经占用了锁S2，当线程A运行到加锁S2时，由于锁S2被线程B占用，线程A会陷入阻塞状态，当线程B运行到加锁S1时，由于锁S1被线程A占用，会导致线程B陷入阻塞状态，两个线程都陷入了阻塞状态，而且自然条件下无法被唤醒，造成了死锁。
🍄情况3：多个线程多把锁 最典型的栗子就是哲学家就餐问题，下面我们来分析哲学家就餐问题。
🍁1.7.2哲学家就餐问题
哲学家就餐问题是迪杰斯特拉这位大佬提出并解决的问题，具体问题如下：
有五位非常固执的科学家每天围在一张圆桌上面吃饭，这个圆桌上一共有5份食物和5根 筷子，哲学家们成天都坐在桌前思考，当饿了的时候就会拿起距离自己最近的2根筷子就餐，但是如果发现离得最近的筷子被其他哲学家占用了，这个哲学家就会一直等，直到旁边的哲学家就餐完毕，这位科学家才会拿起左右的筷子进行就餐，就餐完毕后哲学家们又开始进行思考状态，饿了就再次就餐。
当哲学家们每个人都拿起了左边的筷子或者右边的筷子，由于哲学家们非常地顽固，拿起一只筷子后发现另一只筷子被占用就会一直等待，所以所有的哲学家都会互相地等待，这样就会造成所有哲学家都在等待，即死锁。
🍄从上述的几种造成死锁的情况，可以总结发生死锁的条件：
- 互斥使用，一个锁被一个线程占用后，其他线程使用不了（锁本质，保证原子性）。
- 不可抢占，一个锁被一个线程占用后，其他线程不能将锁抢占。
- 请求和保持，当一个线程占据多把锁后，除非显式释放锁，否则锁一直被该线程锁占用。
- 环路等待，多个线程等待关系闭环了，比如A等B，B等C，C等A。
🍄如何避免环路等待？ 只需约定好，线程针对多把锁加锁时有固定的顺序即可，当所有的线程都按照约定的顺序加锁就不会出现环路等待。
比如对于上述的哲学家就餐问题，我们可以对筷子进行编号，每次哲学家优先拿编号小的筷子就可以避免死锁。
🍀2.CAS指令与ABA问题
🍂2.1CAS指令
CAS即compare and awap，即比较加交换，具体说就是将寄存器或者某个内存上的值v1与另一个内存上的值v2进行比较，如果相同就将v1与需要修改的值swapV进行交换，并返回交换是否成功的结果。
伪代码如下：
boolean CAS(v1, v2, swapV) {
if (v1 == v2) {
v1=swapV;
return true;
}
return false;
}上面的这一段伪代码很明显就是线程不安全的，CPU中提供了一条指令能够一步到位实现上述伪代码的功能，即CAS指令。该指令是具有原子性的，是线程安全的。
java标准库中提供了基于CAS所实现的“原子类”，这些类的类名以Atomic开头，针对常用的int,long等进行了封装，它们可以基于CAS的方式进行修改，是线程安全的。
就比如上次使用多个线程对同一个变量进行自增操作的那个程序，它是线程不安全的，但是如果使用CAS原子类来实现，那就是线程安全的。
其中的getAndIncrement方法相当于i 操作。 现在我们来使用原子类中的“getAndIncrement方法（基于CAS实现）来实现该程序。
import java.util.concurrent.atomic.AtomicInteger;
public class Main {
private static final int CNT = 50000;
public static void main(String[] args) throws InterruptedException {
AtomicInteger count = new AtomicInteger();
Thread thread1 = new Thread(() -> {
for (int i = 0; i < CNT; i ) {
count.getAndIncrement();
}
});
thread1.start();
Thread thread2 = new Thread(() -> {
for (int i = 0; i < CNT; i ) {
count.getAndIncrement();
}
});
thread2.start();
thread1.join();
thread2.join();
System.out.println(count);
}
}🍄运行结果：
从结果我们也能看出来，该程序是线程安全的。
上面所使用的AtomicInteger类方法getAndIncrement实现的伪代码如下：
class AtomicInteger {
private int value;//保存的值
//自增操作
public int getAndIncrement() {
int oldValue = value;
while ( CAS(value, oldValue, oldValue 1) != true) {
oldValue = value;
}
return oldValue;
}
}首先，对于CAS指令，它的执行逻辑就是先判断value的值是否与oldValue的值相同，如果相同就将原来value的值与value 1的值进行交换，相当于将value的值加1，其中oldValue的值为提前获取的value值，在单线程中oldValue的值一定与value的值相同，但是多线程就不一定了，因为每时每刻都有可能被其他线程修改。
然后，我们再来看看下面的while循环，该循环使用CAS指令是否成功为判断条件，如果CAS成功了则退出循环，此时value的值已经加1，最终返回oldValue，因为后置 先使用后 。
如果CAS指令失败了，这就说明有新线程提前对当前的value进行了 ，value的值发生了改变，这时候需要重新保存value的值给oldValue，然后尝试重新进行CAS操作，这样就能保证有几个线程操作，那就自增几次，从而也就保证了线程安全，总的来说相当于传统的 操作，基于CAS的自增操作只有两个指令，一个是将目标值加载到寄存器，然后在寄存器上进行CAS操作，前面使用传统 操作导致出现线程安全问题是指令交错的情况，现在我们来画一条时间轴，描述CAS实现的自增操作在多个线程指令交错时的运行情况。
发现尽管指令交错了，但是运行得到的结果预期也是相同的，也就说明基于CAS指令实现的多线程自增操作是线程安全的。
此外，基于CAS也能够实现自旋锁，伪代码如下：
//这是一个自旋锁对象，里面有一个线程引用，如果该引用不为null，说明当前锁对象被线程占用，反之亦然。
public class SpinLock {
private Thread owner;
public void lock(){
// 通过 CAS 看当前锁是否被某个线程持有.
// 如果这个锁已经被别的线程持有, 那么就自旋等待.
// 如果这个锁没有被别的线程持有, 那么就把 owner 设为当前尝试加锁的线程.
while(!CAS(this.owner, null, Thread.currentThread())){
}
}
public void unlock (){
this.owner = null;
}
}根据CAS与自旋锁的逻辑，如果当前锁对象被线程占用，则lock方法会反复地取获取该锁是否释放，如果释放了即owner==null，就会利用CAS操作将占用该锁对象的线程设置为当前线程，并退出加锁lock方法。
解锁方法非常简单，就将占用锁对象的线程置为null即可。
🍂2.2ABA问题
根据上面的介绍我们知道CAS指令操作的本质是先比较，满足条件后再进行交换，在大部分情况下都能保证线程安全，但是有一种非常极端的情况，那就是一个值被修改后又被改回到原来的值，此时CAS操作也能成功执行，这种情况在大多数的情况是没有影响的，但是也存在问题。
像上述一个值被修改后又被改回来这种情况就是CAS中的ABA问题，虽说对于大部分场景都不会有问题，但是也存在bug，比如有以下一个场景就说明了ABA问题所产生的bug：
有一天。滑稽老铁到ATM机去取款，使用ATM查询之后，滑稽老铁发现它银行卡的余额还有200，于是滑稽老铁想去100块给女朋友买小礼物，但是滑稽老铁取款时，在点击取款按钮后机器卡了一下，滑稽老铁下意识又点了一下，假设这两部取款操作执行图如下：
如果没有出现意外，即使按下两次取款按钮也是正常的，但是在这两次CAS操作之间，如图滑稽老铁的朋友给它转账了100块，导致第一次CAS扣款100后的余额从100变回到了200，这时第二次CAS操作也会执行成功，导致又被扣款100块，最终余额是100块，这种情况是不合理的，滑稽老铁会组织滑稽大军讨伐银行的，合理的情况应该是第二次CAS仍然失败，最终余额为200元。
为了解决ABA问题造成的bug，可以引入应该版本号，版本号只能增加不能减少，加载数据的时候，版本号也要一并加载，每一次修改余额都要将版本号加1， 在进行CAS操作之前，都要对版本号进行验证，如果版本号与之前加载的版本号不同，则放弃此次CAS指令操作。
上面的这张图是引入版本号之后，滑稽老铁账户余额变化图，我们不难发现余额的变化是合理的。
总结一下，本篇文章介绍了常见的锁策略，并说明了synchronized关键字加的锁类型不是单一一种锁类型的，根据可重入锁与非可重入锁引出了死锁的概念与死锁条件，最后介绍了CAS指令以及CAS锁产生的ABA问题及其解决方案。
到此这篇关于Java多线程之常见锁策略与CAS中的ABA问题的文章就介绍到这了,更多相关Java多线程常见锁策略内容请搜索Devmax以前的文章或继续浏览下面的相关文章希望大家以后多多支持Devmax！