前面都是讲的共享模型之加锁,本章介绍共享模型之无锁。
1. CAS 与 volatile
提出问题:
解决一 加锁:
解决二 无锁:
1.1 CAS工作原理
在多核状态下,某个核执行到带 lock 的指令时,CPU 会让总线锁住,当这个核把此指令执行完毕,再开启总线。这个过程中不会被线程的调度机制所打断,保证了多个线程对内存操作的准确性,是原子的。
1.1.1 CAS与volatile配合
volatile
获取共享变量时,为了保证该变量的可见性,需要使用 volatile 修饰。
它可以用来修饰成员变量和静态成员变量,他可以避免线程从自己的工作缓存中查找变量的值,必须到主存中获取它的值,线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改,对另一个线程可见。
注意
volatile 仅仅保证了共享变量的可见性,让其它线程能够看到最新值,但不能解决指令交错问题(不能保证原子性)
CAS 必须借助 volatile 才能读取到共享变量的最新值来实现【比较并交换】的效果。
1.2 为什么CAS比加锁效率高
无锁情况下,即使重试失败,线程始终在高速运行,没有停歇,而 synchronized 会让线程在没有获得锁的时候,发生上下文切换,进入阻塞。打个比喻:
线程就好像高速跑道上的赛车,高速运行时,速度超快,一旦发生上下文切换,就好比赛车要减速、熄火,等被唤醒又得重新打火、启动、加速… 恢复到高速运行,代价比较大。
但无锁情况下,因为线程要保持运行,需要额外 CPU 的支持,CPU 在这里就好比高速跑道,没有额外的跑道,线程想高速运行也无从谈起,虽然不会进入阻塞,但由于没有分到时间片,仍然会进入可运行状态,还是会导致上下文切换。
1.3 CAS 的特点(API)
结合 CAS 和 volatile 可以实现无锁并发,适用于线程数少(少于CPU核心)、多核 CPU 的场景下。
-
CAS 是基于乐观锁的思想:最乐观的估计,不怕别的线程来修改共享变量,就算改了也没关系,我吃亏点再重试呗。
-
synchronized 是基于悲观锁的思想:最悲观的估计,得防着其它线程来修改共享变量,我上了锁你们都别想改,我改完了解开锁,你们才有机会。
-
CAS 体现的是无锁并发、无阻塞并发,仔细体会这两句话的意思。
因为没有使用 synchronized,所以线程不会陷入阻塞,这是效率提升的因素之一。
但如果竞争激烈,可以想到重试必然频繁发生,反而效率会受影响。
2. 原子整数
使用CAS实现的工具类,J.U.C提供了AtomicBoolean、AtomicInteger、AtomicLong
3. 原子引用
除了基本类型,还有引用类型(小数,字符串,对象)
3.1和3.2比较的就是两种写法,重点看3.2无锁使用原子引用。
3. 1 安全实现-使用锁
3. 2 安全实现-使用CAS
3. 3 ABA问题
描述的问题是:
主线程仅能判断出共享变量的值与最初值 A 是否相同,不能感知到这种从 A 改为 B 又 改回 A 的情况。
如果主线程希望:
只要有其它线程【动过了】共享变量,那么自己的 cas 就算失败,这时,仅比较值是不够的,需要再加一个版本号。
![[uTools_1688810741592.png]]
AtomicStampedReference
可以给原子引用加上版本号,追踪原子引用整个的变化过程,如:
A -> B -> A ->C ,通过AtomicStampedReference,我们可以知道,引用变量中途被更改了几次。
但是有时候,并不关心引用变量更改了几次,只是单纯的关心是否更改过,所以就有了
AtomicMarkableReference
。
(前面是整数记录版本,但现在只想知道改没改,只需要一个布尔值)
![[uTools_1688811152435.png]]
4. 原子数组 △△
有的时候并不想修改引用对象本身,而是引用对象里面的内容(数组)。比如多个线程并不想修改数组引用地址,而是修改数组里的元素。就要用到原子数组了。
AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray
举例:(注意函数式接口的写法)
/**
参数1,提供数组、可以是线程不安全数组或线程安全数组
参数2,获取数组长度的方法
参数3,自增方法,回传 array, index
参数4,打印数组的方法
*/
// **********************函数式接口**********************
// supplier 提供者 无中生有: ()->结果
// function 函数 一个参数一个结果: (参数)->结果 , BiFunction: (参数1,参数2)->结果
// consumer 消费者 一个参数没结果: (参数)->void, BiConsumer: (参数1,参数2)->void
private static <T> void demo(
Supplier<T> arraySupplier,
Function<T, Integer> lengthFun,
BiConsumer<T, Integer> putConsumer,
Consumer<T> printConsumer ) {
List<Thread> ts = new ArrayList<>();
T array = arraySupplier.get();
int length = lengthFun.apply(array);
for (int i = 0; i < length; i++) {
// 每个线程对数组作 10000 次操作
ts.add(new Thread(() -> {
for (int j = 0; j < 10000; j++) {
putConsumer.accept(array, j%length);
}
}));
}
ts.forEach(t -> t.start()); // 启动所有线程
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}); // 等所有线程结束
printConsumer.accept(array);
}
4.1 调用时,传参:
不安全数组
安全数组
5. 字段更新器
刚才是保护数组中的元素,现在这个是==保护对象里的成员变量(属性)的线程安全。==多个线程访问一个类的成员变量。
AtomicReferenceFieldUpdater // 域 字段 、AtomicIntegerFieldUpdater、AtomicLongFieldUpdater
更新的是Student对象里的String成员变量,也是一个引用,所以用AtomicReferenceFieldUpdater
6. 原子累加器
AtomicLong 与 LongAdder
性能提升的原因很简单,就是在有竞争时,设置多个累加单元,Therad-0 累加 Cell[0],而 Thread-1 累加Cell[1]… 最后将结果汇总。这样它们在累加时操作的不同的 Cell 变量,因此减少了 CAS 重试失败,从而提高性能。
6. 1 LongAdder
// 累加单元数组, 懒惰初始化
transient volatile Cell[] cells;
// 基础值, 如果没有竞争, 则用 cas 累加这个域
transient volatile long base;
// 在 cells 创建或扩容时, 置为 1, 表示加锁
transient volatile int cellsBusy;
6.1.1 原理之伪共享
6.1.1.1 缓存与内存的速度比较
因为 CPU 与 内存的速度差异很大,需要靠预读数据至缓存来提升效率。
而缓存以缓存行为单位,每个缓存行对应着一块内存,一般是 64 byte(8 个 long)
缓存的加入会造成数据副本的产生,即同一份数据会缓存在不同核心的缓存行中。
CPU 要保证数据的一致性,如果某个 CPU 核心更改了数据,其它 CPU 核心对应的整个缓存行必须失效。
![[uTools_1688857240831.png]]
因为 Cell 是数组形式,在内存中是连续存储的,一个 Cell 为 24 字节(16 字节的对象头和 8 字节的 value),因此缓存行可以存下 2 个的 Cell 对象。这样问题来了:
Core-0 要修改 Cell[0]
Core-1 要修改 Cell[1]
无论谁修改成功,都会导致对方 Core 的缓存行失效,比如Core-0 中 Cell[0]=6000, Cell[1]=8000
要累加Cell[0]=6001, Cell[1]=8000
,这时会让 Core-1 的缓存行失效。
解决方法:
放在不同缓存行。
@sun.misc.Contended
用来解决这个问题,它的原理是在使用此注解的对象或字段的前后各增加 128 字节大小的padding,从而让 CPU 将对象预读至缓存时占用不同的缓存行,这样,不会造成对方缓存行的失效。
// LongAdder的increment的源码是一个add方法
public void add(long x) {
// as 为累加单元数组
// b 为基础值
// x 为累加值
Cell[] cs; long b, v; int m; Cell c;
// 进入 if 的两个条件
// 1. as 有值, 表示已经发生过竞争, 进入 if
// 2. cas 给 base 累加时失败了, 表示 base 发生了竞争, 进入 if
if ((cs = cells) != null || !casBase(b = base, b + x)) {
// uncontended 表示 cell 没有竞争
boolean uncontended = true;
if (
cs == null || (m = cs.length - 1) < 0 || // as 还没有创建
(c = cs[getProbe() & m]) == null || // 当前线程对应的 cell 还没有
// cas 给当前线程的 cell 累加失败 uncontended=false ( a 为当前线程的 cell )
!(uncontended = c.cas(v = c.value, v + x)))
// 进入 cell 数组创建、cell 创建的流程
longAccumulate(x, null, uncontended);
}
}
longAccumulate 流程图:
7. Unsafe
Unsafe 对象提供了非常底层的,操作内存、线程的方法,Unsafe 对象不能直接调用,只能通过反射获得。(CAS都是调用了unsafe的方法)
反射
- 我们编译时知道类或对象的具体信息,此时直接对类和对象进行操作即可,无需使用反射(reflection)
- 如果编译不知道类或对象的具体信息,此时应该如何做呢?这时就要用到 反射 来实现。比如类的名称放在XML文件中,属性和属性值放在XML文件中,需要在运行时读取XML文件,动态获取类的信息。
public class UnsafeAccessor {
static Unsafe unsafe;
static {
try {
// 反射获取私有成员变量用getDeclaredField
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
// 允许访问私有成员变量
theUnsafe.setAccessible(true);
unsafe = (Unsafe) theUnsafe.get(null);
} catch (NoSuchFieldException | IllegalAccessException e) {
throw new Error(e);
}
}
static Unsafe getUnsafe() {
return unsafe;
}
}
7.1 Unsafe CAS 操作
用更高层就是AtomicFileAdpater修改对象的域,此时是更底层的修改。