避免代价过大的加锁-乐观锁

Ahuans

于 2023-07-30 01:33:21 发布

阅读量104

点赞数

分类专栏：全面掌握java高并发文章标签：性能优化 java 开发语言

本文链接：https://blog.csdn.net/Ahuans/article/details/132002549

版权

全面掌握java高并发专栏收录该内容

6 篇文章 0 订阅

订阅专栏

文章目录

无锁并发（乐观锁）
1. CAS（CompareAndSet）
2.原子整数（用CAS方法实现的类：AutomicInteger）
3. 原子引用（AutomicReference）
4.原子数组
5. 原子更新器
6.原子累加器（LongAdder）
7.Unsafe
- 7.1Unsafe进行CAS修改操作

无锁并发（乐观锁）

不怕别的线程来修改自己的变量，就算修改了，我不断尝试去修改，总有一次在没有被其他县城修改的情况下进行修改

1. CAS（CompareAndSet）

i.CompareAndSet（pre，next）这个方法的本意是将a的值改为next的值，但是在多线程中，因为其他线程可能会对a进行操作，所以这个a不一定是这个线程操作a时本来的a了，所以将a与pre进行对比之后，如果相同，说明其他线程还没操作过a，那么修改成功，该方法也会返回一个true
如下图实现，不断循环以遇上a还没有被修改的情况

public void withdraw(Integer amount){
	while(true){
		int prev=balance.get();
		int next=prev-amount;
		if(balance.compareAndSet(prev,next)){
			break;
		}
	}
}

CompareAndSet中的变量一定要使用volatile进行修饰，因为需要不断从主存中获取最新值来与pre进行比较，查看a是否已经被其他线程修改。
无锁并发最好在多核情况使用，因为无锁最主要的是防止线程进入阻塞从而上下文切换产生较大代价，提升效率，但是CPU太少了，这个线程没有被分配到时间片，它还是会上下文切换。

2.原子整数（用CAS方法实现的类：AutomicInteger）

在这里插入图片描述

上面这个方法（方法的参数有FunctionalInterface接口实现，和之前的Runnable一样，可以直接用方法lambda表达式来传参）的实现逻辑，等于下面这些代码的实现逻辑：

while(true){
	int prev=i.get();
	int next=prev*10;
	if(i.compareAndSet(prev,next)){
		break;
	}
}

真正的实现方法：

public final int updateAndGet(IntUnaryOperator updateFunction){
	int prev,next;
	do{
		prev=get();
		next=updateFunction.applyAsInt(prev);
		
	}while(!compareAndSet(prev,next));
	return next;
}

3. 原子引用（AutomicReference）

在这里插入图片描述
以下面这种方式表达对某个类进行引用：对BigDecimal类进行引用

private AtomicReference<BigDecimal> balance;

AtomicStampedReference可以查看变量在之前有没有被修改，有些变量被修改后又被改回来了，AtomicReference检查不出来的，通过getStamp()方法获取版本号。
初始化方法：

AtomicStampedReference<String> ref=new AtomicStampedReference<>("A",0);

CAS操作可以改为如下代码
在这里插入图片描述
如果发生了CAS操作，先去对比这个版本（在之前int stamp=ref.getStamp方法中已经被提前保存）有没有在之前被别人修改过了，如果没有，就给版本号+1，可以看出这个类可以检查被修改过几次。

而AutomicMarkableReference可以只查看有没有被修改过
在这里插入图片描述

修改了就把initialMark换成false

4.原子数组

在这里插入图片描述

5. 原子更新器

在这里插入图片描述

修改该类对应对象中的成员变量方法：

6.原子累加器（LongAdder）

6.1 累加器的优势

当有多个线程操纵某个共享变量进行累加时，每个线程都是用CAS会不断地去循环尝试累加（乐观锁CAS只要失败，循环回到刚开始继续尝试去操作），线程就停在这个循环不动了，效率不高。
LongAdder在类中实现了一个cells数组，当线程竞争发生时，就创建数组，并使每一个线程对应操作数组中的一个元素进行累加，我刚开始的疑问是，既然每个线程操作的对象都不同了，这个变量他还算共享吗，刚开始是1，两个线程都加1，那么不是两个2吗，但是我们需要的结果是3呀。原来是这个类中在每个cell中只记录加了多少，在累加的最后会实现一个sum方法，把一共加了多少统计起来，最后再加到刚开始的数上，这样子就实现了不让每个线程都等待CAS的循环，提高了效率。

6.2 累加器成员变量

1、 Cell[] cells
这个就是核心部分，该变量是懒惰创建，只有当线程竞争发生时才会进入创建逻辑
2、 base
这个base就是指刚开始的数，如果没有竞争，就在base上累加，有竞争就作为基本数在最后的sum中运用
3、 cellsBusy
这个变量实现了一个CAS锁，cellsBusy为0代表现在还没有进程拥有该锁，当进程尝试加锁时，会尝试使用CAS操作将cellsBusy设置为1，如果尝试失败就不断循环。当需要释放锁时，只需要把cellsBusy置为0就行了，因为这个时候没有线程有资格操作cellsBusy，不需要cas操作去保证原子性。实现原理如下图所示
在这里插入图片描述

6.3 避免伪共享

因为cells是数组，数组在内存中一般是连续存储的，CPU为了提高效率会将进场读写的数据存入缓存行，但是缓存行是一块一块进行存储，也就是说一个线程可能只需要数组中的第一个cell，但是存入缓存行的确是整个数组，那么为了保证安全，每次修改数组数据时，都需要把整个缓存行在主存中对应的数据标记为失效，其他需要操作这个数组的线程也被迫需要修改自己缓存行的数据，降低了效率。
在这里插入图片描述
使用@sun.misc.Contented注释来修饰一个类，这个类的每一个对象末尾都会在主存中被添加一个padding，使其能够到达缓存行一块的大小，这样每个CPU存入缓存行的就只是它需要的数据而不会影响数组中其他的数据的修改。
在这里插入图片描述