文章目录
前言
从(5)开始讨论无锁的内容,也就是CAS。文章参考《Java并发编程的艺术》这本书以及黑马的视频 黑马多线程。无锁对于一个程序的性能提高起到很重要的作用。
1. 问题引出
现在我们来看一段代码,有如下需求,保证 account.withdraw 取款方法的线程安全。程序中定义了1000个线程来进行取款的操作,下面使用 synchronized 来保证线程安全
使用 Synchrinized 来解决 |
public class Test5 {
public static void main(String[] args) {
Account.demo(new AccountUnsafe(10000));
}
}
class AccountUnsafe implements Account {
private Integer balance;
public AccountUnsafe(Integer balance) {
this.balance = balance;
}
@Override
public Integer getBalance() {
synchronized(this){
return balance;
}
}
@Override
public void withdraw(Integer amount) {
// 通过这里加锁就可以实现线程安全,不加就会导致结果异常
synchronized (this){
balance -= amount;
}
}
}
interface Account {
// 获取余额
Integer getBalance();
// 取款
void withdraw(Integer amount);
//启动1000个线程,这里我们测试1000次之后的synchronized的效率怎么样
static void demo(Account account) {
List<Thread> ts = new ArrayList<>();
long start = System.nanoTime();
for (int i = 0; i < 1000; i++) {
ts.add(new Thread(() -> {
account.withdraw(10);
}));
}
ts.forEach(Thread::start);
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
long end = System.nanoTime();
System.out.println(account.getBalance()
+ " cost: " + (end-start)/1000_000 + " ms");
}
}
输出结果:
使用 CAS 来解决 |
public class TestAccount {
public static void main(String[] args) {
Account account = new AccountCas(10000);
Account.demo(account);
}
}
class AccountCas implements Account {
//原子整数
private AtomicInteger balance;
public AccountCas(int balance) {
this.balance = new AtomicInteger(balance);
}
@Override
public Integer getBalance() {
return balance.get();
}
//取款操作,使用 CAS 来进行
@Override
public void withdraw(Integer amount) {
while(true) {
// 获取余额的最新值
int prev = balance.get();
// 要修改的余额
int next = prev - amount;
// 真正修改,compareAndSet(原来值,后来值)
if(balance.compareAndSet(prev, next)) {
break;
}
}
//balance.getAndAdd(-1 * amount);
}
}
class AccountUnsafe implements Account {
private Integer balance;
public AccountUnsafe(Integer balance) {
this.balance = balance;
}
@Override
public Integer getBalance() {
synchronized (this) {
return this.balance;
}
}
@Override
public void withdraw(Integer amount) {
synchronized (this) {
this.balance -= amount;
}
}
}
interface Account {
// 获取余额
Integer getBalance();
// 取款
void withdraw(Integer amount);
//启动1000个线程来进行操作,看看最终的结果是什么
static void demo(Account account) {
List<Thread> ts = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
ts.add(new Thread(() -> {
account.withdraw(10);
}));
}
long start = System.nanoTime();
ts.forEach(Thread::start);
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
long end = System.nanoTime();
System.out.println(account.getBalance()
+ " cost: " + (end-start)/1000_000 + " ms");
}
}
输出结果:
对比 |
- 使用 CAS 只需要 48 ms,而使用 synchronized 需要 189 ms,可以看到使用 CAS 的执行效率是高于 synchronized 的
2. CAS 和 volatile
1. CAS
前面看到的使用了一个原子类 AtomicInteger
来确保线程安全,下面来看看那段代码是如何保证线程安全的。下面就给出实现的步骤
- 线程 A 首先进入 while(true) 循环操作变量修改
- 线程 A 获取到要修改的变量的值
- 线程 A 设置修改后的值
- 使用 CAS 操作修改,也就是 compareAndSet
- 举个例子,比如当前线程获取到的 prev 是 1000,而这时候其他线程把值修改为了 990,那么此时当前线程对 1000 的修改就是无效的,需要再次进入 while 循环
注意
- 其实 CAS 的底层是 lock cmpxchg 指令(X86 架构),在单核 CPU 和多核 CPU 下都能够保证【比较-交换】的原子性。
- 在多核状态下,某个核执行到带 lock 的指令时,CPU 会让总线锁住,当这个核把此指令执行完毕,再开启总线。这个过程中不会被线程的调度机制所打断,保证了多个线程对内存操作的准确性,是原子的。这个 lock 指令在之前写过的那篇文章详细聊聊volatile中有谈到
- CAS使用场景最好的线程数不要超过 CPU 核心数,才可以充分发挥其作用
@Override
public void withdraw(Integer amount) {
// 核心代码
// 需要不断尝试,直到成功为止
while (true){
// 比如拿到了旧值 1000
int pre = getBalance();
// 在这个基础上 1000-10 = 990
int next = pre - amount;
/*
compareAndSet 正是做这个检查,在 set 前,先比较 prev 与当前值
- 不一致了,next 作废,返回 false 表示失败
比如,别的线程已经做了减法,当前值已经被减成了 990
那么本线程的这次 990 就作废了,进入 while 下次循环重试
- 一致,以 next 设置为新值,返回 true 表示成功
*/
if (atomicInteger.compareAndSet(pre,next)){
break;
}
}
}
下面再来看一个例子,一步一步来解释 CAS 是这么运作的,如果看不懂代码直接看结果也可以,结果把一些注意的地方都输出了。
@Slf4j
public class SlowMotion {
public static void main(String[] args) {
AtomicInteger balance = new AtomicInteger(10000);
//当前的值,此时等于1000
int mainPrev = balance.get();
//输出当前值
log.debug("主线程获取到了值 {}", mainPrev);
new Thread(() -> {
//线程睡眠1秒
sleep(1000);
//获取当前值
int prev = balance.get();
log.debug("t1线程要把{}修改为9000", prev);
//要修改为9000,也就是从 10000 -> 9000
balance.compareAndSet(prev, 9000);
log.debug("t1线程最终修改为 {}", balance.toString());
}, "t1").start();
//睡眠两秒
log.debug("主线程睡眠两秒");
sleep(2000);
log.debug("主线程尝试设置为 8000...");
//使用compareAndSet(10000, 8000)
//但是结果都知道是不能执行的,因为此时的数已经改成了9000了
boolean isSuccess = balance.compareAndSet(mainPrev, 8000);
log.debug("主线程从{}修改为8000成功了吗 ? {}", mainPrev, isSuccess);
if(!isSuccess){
log.debug("主线程没有成功,再次尝试设置为8000");
mainPrev = balance.get();
log.debug("主线程获取到了当前值,当前值是{}", mainPrev);
//再次设置
isSuccess = balance.compareAndSet(mainPrev, 8000);
log.debug("主线程修改为8000成功了吗 ? {}", isSuccess);
}
log.debug("两个线程经过一系列的修改后的值是:{}", balance.get());
}
private static void sleep(int millis) {
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
输出结果:
2. volatile
关于 volatile,这里就简单提一嘴:具体的在详解volatile 有谈到,这篇文章介绍的还是很详细的。
获取共享变量时,为了保证该变量的可见性,需要使用 volatile 修饰。它可以用来修饰成员变量和静态成员变量,他可以避免线程从自己的工作缓存中查找变量的值,必须到主存中获取它的值,线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改,对另一个线程可见。
注意
- volatile 仅仅保证了共享变量的可见性,让其它线程能够看到最新值,但不能解决指令交错问题(不能保证原子性)
- CAS 必须借助 volatile 才能读取到共享变量的最新值来实现【比较并交换】的效果,去查看源码也可以看到
3. 为什么无锁效率高
- 无锁情况下,即使重试失败,线程始终在高速运行,没有停歇,而synchronized 会让线程在没有获得锁的时候,发生上下文切换,进入阻塞。打个比喻
- 线程就好像高速跑道上的赛车,高速运行时,速度超快,一旦发生上下文切换,就好比赛车要减速、熄火,等被唤醒又得重新打火、启动、加速… 恢复到高速运行,代价比较大
- 但无锁情况下,因为线程要保持运行,需要额外 CPU 的支持,CPU 在这里就好比高速跑道,没有额外的跑道,线程想高速运行也无从谈起(没分到时间片的时候还是会不断循环),虽然不会进入阻塞,但由于没有分到时间片,仍然会进入可运行状态,还是会导致上下文切换。
4. CAS 的特点
结合 CAS 和 volatile 可以实现无锁并发,适用于线程数少、多核 CPU 的场景下。
-
CAS 是基于乐观锁的思想:最乐观的估计,不怕别的线程来修改共享变量,就算改了也没关系,反正一直都是在 while 循环,大不了就再循环就行了
-
synchronized 是基于悲观锁的思想:最悲观的估计,得防着其它线程来修改共享变量,我上了锁你们都别想改,我改完了解开锁,你们才有机会。
-
CAS 体现的是无锁并发、无阻塞并发,请仔细体会这两句话的意思
- 因为没有使用 synchronized,所以线程不会陷入阻塞,这是效率提升的因素之一
- 但如果竞争激烈,可以想到重试必然频繁发生,反而效率会受影响
3. 原子整数
J.U.C 并发包提供了:
- AtomicBoolean:布尔型原子类
- AtomicInteger:整形原子类
- AtomicLong:长整型原子类
以 AtomicInteger 为例,下面介绍里面的一些方法是如何使用的:
public class testAtom{
public static void main(String[] args) {
AtomicInteger i = new AtomicInteger(0);
// 获取并自增(i = 0, 结果 i = 1, 返回 0),类似于 i++
System.out.println(i.getAndIncrement());
// 自增并获取(i = 1, 结果 i = 2, 返回 2),类似于 ++i
System.out.println(i.incrementAndGet());
// 自减并获取(i = 2, 结果 i = 1, 返回 1),类似于 --i
System.out.println(i.decrementAndGet());
// 获取并自减(i = 1, 结果 i = 0, 返回 1),类似于 i--
System.out.println(i.getAndDecrement());
// 获取并加值(i = 0, 结果 i = 5, 返回 0)
System.out.println(i.getAndAdd(5));
// 加值并获取(i = 5, 结果 i = 0, 返回 0)
System.out.println(i.addAndGet(-5));
// 获取并更新(i = 0, p 为 i 的当前值, 结果 i = -2, 返回 0)
// 函数式编程接口,其中函数中的操作能保证原子,但函数需要无副作用
System.out.println(i.getAndUpdate(p -> p - 2));
// 更新并获取(i = -2, p 为 i 的当前值, 结果 i = 0, 返回 0)
// 函数式编程接口,其中函数中的操作能保证原子,但函数需要无副作用
System.out.println(i.updateAndGet(p -> p + 2));
// 获取并计算(i = 0, p 为 i 的当前值, x 为参数1, 结果 i = 10, 返回 0)
// 函数式编程接口,其中函数中的操作能保证原子,但函数需要无副作用
// getAndUpdate 如果在 lambda 中引用了外部的局部变量,要保证该局部变量是 final 的
// getAndAccumulate 可以通过 参数1 来引用外部的局部变量,但因为其不在 lambda 中因此不必是 final
System.out.println(i.getAndAccumulate(10, (p, x) -> p + x));
// 计算并获取(i = 10, p 为 i 的当前值, x 为参数1值, 结果 i = 0, 返回 0)
// 函数式编程接口,其中函数中的操作能保证原子,但函数需要无副作用
System.out.println(i.accumulateAndGet(-10, (p, x) -> p + x));
}
}
下面我们找几个方法去看看里面的源码,看看内部是如何实现的:
其实只要去原子类内部看看,就大概直到这里面几乎都是使用了 unsafe 的方法来实现的。而 Unsafe 类中的方法几乎都用了以下的这些方法,从名字上来看都是获取 volatile 方法,其他的可以自己去底层来看,基本都调用了这些方法。并且只要查看源码,也可以看到这里面的方法使用了 compareAndSet 方法,所以这个类在保证了高效的同时也保证了原子性。
4. 原子引用
为什么需要原子引用类型?我们需要维持的线程安全的类型不只是基本数据类型,对于引用类型也需要去维护,下面是三种原子引用类型:
- AtomicReference:原子更新引用类型
- AtomicMarkableReference:一个线程安全的原子类,里面封装了一个对象引用和一个布尔类型的 mark 值
- AtomicStampedReference:一个带有时间戳的对象引用,使用这个原子引用可以解决 ABA 问题
下面来看一个例子,使用原子引用来取款,当然如果不想用 CAS 可以把循环那块换成锁来实现就可以了:
public class Test35 {
public static void main(String[] args) {
//初始化 10000 存款
DecimalAccount.demo(new DecimalAccountCas(new BigDecimal("10000")));
}
}
class DecimalAccountCas implements DecimalAccount {
private AtomicReference<BigDecimal> balance;
public DecimalAccountCas(BigDecimal balance) {
// this.balance = balance;
this.balance = new AtomicReference<>(balance);
}
@Override
public BigDecimal getBalance() {
return balance.get();
}
@Override
public void withdraw(BigDecimal amount) {
//CAS来取款
while(true) {
BigDecimal prev = balance.get();
BigDecimal next = prev.subtract(amount);
if (balance.compareAndSet(prev, next)) {
break;
}
}
}
}
interface DecimalAccount {
// 获取余额
BigDecimal getBalance();
// 取款
void withdraw(BigDecimal amount);
/**
* 方法内会启动 1000 个线程,每个线程做 -10 元 的操作
* 如果初始余额为 10000 那么正确的结果应当是 0
*/
static void demo(DecimalAccount account) {
List<Thread> ts = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
ts.add(new Thread(() -> {
//1000个线程,调用取款操作,每一个线程 -10
account.withdraw(BigDecimal.TEN);
}));
}
ts.forEach(Thread::start);
ts.forEach(t -> {
try {
//快的线程等慢的线程执行
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println(account.getBalance()); //0
}
}
输出结果:
1. ABA问题及其解决
有这么一种情况,如果一个原子类的共享变量经过了两次的修改,第一次从 1-> 0,第二次从 0 -> 1,那么此时的共享变量已经被修改过了,但是从结果上来说是不变的,所以我们可能会认为这个变量没有被修改,但是其实变量被修改了 2 次了。下面来看这一段代码:
@Slf4j
public class TestABA {
static AtomicReference<String> ref = new AtomicReference<>("A");
public static void main(String[] args) throws InterruptedException {
log.debug("main start...");
// 获取值 A
String prev = ref.get();
//调用方法修改这个变量
other();
sleep(1);
// 尝试改为 C
log.debug("change A->C {}", ref.compareAndSet(prev, "C"));
}
private static void other() {
new Thread(() -> {
//从 A -> B
log.debug("change A->B {}", ref.compareAndSet(ref.get(), "B"));
}, "t1").start();
sleep(0.5);
new Thread(() -> {
//从 B -> A
log.debug("change B->A {}", ref.compareAndSet(ref.get(), "A"));
}, "t2").start();
}
}
结果输出:
这段代码中,A 先修改为 B,然后 B 再修改为 A,主线程再使用 A 修改为 C,而对于主线程来说其实中间的修改对于结果没有影响的,这种情况我们可以忽略。但是有时候我们需要严格把控这个对象的版本号。
举一个例子:我们把代码先 git 提交一次,然后修改了再 git 一次,但是这时候我们发现修改后的代码还没有原来的代码好,所以又改了回来再 git 提交一次,整个过程就实现了一个 A-B-A 过程,但是虽然代码改回来了,但是版本号是不同的。我们通过不同的版本号就可以直到中间发生了什么。
回到程序,我们也希望对于当前使用的变量,严格要求一定是原来版本的,别人修改过的我不要。那么要实现这种效果,可以使用下面这些原子引用类,这些原子类中添加了版本号。
2. AtomicStampedReference
这个原子类可以用来追踪原子类整个变化过程,下面看这段代码:
public class Test36 {
//定义一个AtomicStampedReference类,设置初始值为'A',初始版本为0
static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
public static void main(String[] args) throws InterruptedException {
log.debug("主线程开始运行");
// 获取值 A
String prev = ref.getReference();
// 获取版本号
int stamp = ref.getStamp();
log.debug("主线程获取了值 {}, 版本 {}",prev, stamp);
// 如果中间有其它线程干扰,发生了 ABA 现象
other();
sleep(1);
// 主线程尝试改为 C
log.debug("主线程设置 A->C {},并修改版本为 {}", ref.compareAndSet(prev, "C", stamp, stamp + 1), stamp + 1);
log.debug("最后的值是多少:{}", ref.getReference());
}
private static void other() {
new Thread(() -> {
log.debug("线程t1设置 A->B {}", ref.compareAndSet(ref.getReference(), "B", ref.getStamp(), ref.getStamp() + 1));
log.debug("线程t1设置完后,更新版本为 {}", ref.getStamp());
}, "t1").start();
sleep(0.5);
new Thread(() -> {
log.debug("线程t2设置 B->A {}", ref.compareAndSet(ref.getReference(), "A", ref.getStamp(), ref.getStamp() + 1));
log.debug("线程t2更新版本为 {}", ref.getStamp());
}, "t2").start();
}
}
最终的输出结果,从输出结果可以看到最后主线程输出结果还是 A,也就是版本号变了之后无法修改成功了:
3. AtomicMarkableReference
AtomicStampedReference 可以给原子引用加上版本号,追踪原子引用整个的变化过程,如: A -> B -> A -> C ,通过AtomicStampedReference,我们可以知道,引用变量中途被更改了几次。但是有时候我们不需要直到改变了多少次,只需要直到有没有被修改过,所以引出了下面的类:AtomicMarkableReference
来看这段代码,我们设置一个主线程类负责放垃圾,然后保洁阿姨负责丢垃圾并更换垃圾袋,最后主线程检查垃圾袋并尝试更换,但是结果可以猜测到是换不了的,因为保洁阿姨已经换了:
@Slf4j
public class Test38 {
public static void main(String[] args) throws InterruptedException {
GarbageBag bag = new GarbageBag("装满了垃圾");
// 参数2 mark 可以看作一个标记,表示垃圾袋满了,开始假设这里的垃圾已经是满的了
AtomicMarkableReference<GarbageBag> ref = new AtomicMarkableReference<>(bag, true);
log.debug("主线程开始运行");
GarbageBag prev = ref.getReference();
log.debug("主线程{}", prev.desc);
new Thread(() -> {
log.debug("保洁阿姨开始工作");
//此时处理成空垃圾袋
bag.setDesc("空垃圾袋");
ref.compareAndSet(bag, bag, true, false);
log.debug("保洁阿姨把满的垃圾袋换成了{}", ref.getReference().desc);
},"保洁阿姨").start();
sleep(1);
log.debug("主线程想换一只新垃圾袋");
boolean success = ref.compareAndSet(prev, new GarbageBag("空垃圾袋"), true, false);
log.debug("主线程换垃圾袋成功了么?" + success);
log.debug("垃圾袋状态是:{}", ref.getReference().desc);
}
}
class GarbageBag {
String desc;
public GarbageBag(String desc) {
this.desc = desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
@Override
public String toString() {
return super.toString() + " " + desc;
}
}
执行结果:垃圾袋被其他线程更换之后主线程再想要更换就不想了
5. 原子数组
使用原子的方式更新数组里的某个元素,上面的原子引用是修改引用本身,有时候我们并不需要修改引用本身,而是应该修改引用内部的数据,比如数组,我们修改的时候需要的是修改数组里面的内容,而不是修改数组本身。这时候就需要数组类原子类了。
- AtomicIntegerArray:整形数组原子类
- AtomicLongArray:长整形数组原子类
- AtomicReferenceArray :引用类型数组原子类
1. 四大函数式接口
首先再开始介绍原子数组前先介绍四大函数式接口,注意这里只给出定义,具体如果自己想要了解可以去看源码,了解用法即可:
1、Consumer:消费型接口
从接口的类型大概可以拆除,整个接口只有接收参数没有返回参数
@FunctionalInterface
public interface Consumer<T> {
/**
* Performs this operation on the given argument.
* @param t the input argument
*/
void accept(T t);
}
2、Supplier:供给型接口
这种接口不需要传入参数,只需要接收返回值即可
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
* @return a result
*/
T get();
}
3、Function<T, R>:函数型接口
这种接口有参数传入也会有参数返回值
@FunctionalInterface
public interface Function<T, R> {
/**
* Applies this function to the given argument.
* @param t the function argument
* @return the function result
*/
R apply(T t);
}
4、Predicate:断言型接口
这种接口有参数传入,返回值是一个布尔类型的变量
@FunctionalInterface
public interface Predicate<T> {
/**
* Evaluates this predicate on the given argument.
* @param t the input argument
* @return {@code true} if the input argument matches the predicate,
* otherwise {@code false}
*/
boolean test(T t);
}
2. 代码
使用到上面的函数式接口进行编程,程序的主要目的是调用10000 个线程进行给数组下标的值 ++ 的操作,按理来说应该是每个下标 1000 次,最终的结果是每个下标的结果都是1000,但是由于第一个测试的是普通数组,存在线程安全问题,所以最后的结果不会是每个下标都是 1000。而对于第二个测试因为是原子数组,那么就是线程安全的,所以最终的结果是每个下标都是 1000。
public class Test39 {
public static void main(String[] args) {
demo(
//1.长度为10的普通数组
()->new int[10],
//2.求数组长度
(array)->array.length,
//3.对应下标的数据++
(array, index) -> array[index]++,
//4.输出数组
array-> System.out.println(Arrays.toString(array))
);
demo(
//1.长度为10的原子类数组
()-> new AtomicIntegerArray(10),
//2.求原子数组的长度
(array) -> array.length(),
//3.对应下标的数据++
(array, index) -> array.getAndIncrement(index),
//4.输出数组
array -> System.out.println(array)
);
}
/**
参数1,提供数组、可以是线程不安全数组或线程安全数组
参数2,获取数组长度的方法
参数3,自增方法,回传 array, index
参数4,打印数组的方法
*/
// supplier 提供者 无中生有 ()->结果
// function 函数 一个参数一个结果 (参数)->结果 , BiFunction (参数1,参数2)->结果
// consumer 消费者 一个参数没结果 (参数)->void, BiConsumer (参数1,参数2)->
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);
}
}
结果输出:
6. 原子更新器
- AtomicReferenceFieldUpdater:基于反射的工具类,用来将指定类型的指定的volatile引用字段进行原子更新
- AtomicIntegerFieldUpdater:原子更新整型字段的更新器
- AtomicLongFieldUpdater:原子更新长整型字段的更新器
要想原子地更新字段类需要同步。第一,因为原子更新字段类都是抽象类,每次访问的时候必须使用静态方法 new Updater() 创建一个更新器,并且需要设置想要更新的类和属性。第二步,更新类的字段(属性)必须使用 private volatile 修饰符。
public class Test5 {
private volatile int field;
public static void main(String[] args) {
//反射给Test5.class这个类中的field属性进行赋值
AtomicIntegerFieldUpdater fieldUpdater = AtomicIntegerFieldUpdater.newUpdater(Test5.class, "field");
Test5 test5 = new Test5();
//修改test5对象中的field属性从0变成10
fieldUpdater.compareAndSet(test5, 0, 10);
// 修改成功 field = 10
System.out.println(test5.field);
// 修改成功 field = 20
fieldUpdater.compareAndSet(test5, 10, 20);
System.out.println(test5.field);
// 修改失败 field = 20
fieldUpdater.compareAndSet(test5, 10, 30);
System.out.println(test5.field);
}
}
7. 原子累加器
1. 累加器性能比较
下面来看一段代码,代码中使用原子类型的Long类型进行累加和使用累加类型的LongAdder进行对比
public class Test41 {
public static void main(String[] args) {
//使用普通的原子类
for (int i = 0; i < 5; i++) {
demo(
() -> new AtomicLong(0),
(adder) -> adder.getAndIncrement(),
"原子类"
);
}
//使用原子累加类
for (int i = 0; i < 5; i++) {
demo(
() -> new LongAdder(),
adder -> adder.increment(),
"累加类"
);
}
}
/*
() -> 结果 提供累加器对象
(参数) -> 执行累加操作
*/
private static <T> void demo(Supplier<T> adderSupplier, Consumer<T> action, String name) {
T adder = adderSupplier.get();
List<Thread> ts = new ArrayList<>();
// 4 个线程,每人累加 50 万次
for (int i = 0; i < 4; i++) {
ts.add(new Thread(() -> {
for (int j = 0; j < 500000; j++) {
//调用accept接收原子类对象进行相加
action.accept(adder);
}
}));
}
long start = System.nanoTime();
//线程开始运行
ts.forEach(t -> t.start());
//线程等待运行结束
ts.forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
long end = System.nanoTime();
System.out.println(name + ": " + adder + " cost:" + (end - start) / 1000_000);
}
}
结果:可以发现,累加类的效率要高于原子类的
性能提升的原因很简单,就是在有竞争时,设置多个累加单元(但不会超过cpu的核心数),Therad-0 累加 Cell[0],而 Thread-1 累加Cell[1]… 最后将结果汇总。这样它们在累加时操作的不同的 Cell 变量,因此减少了 CAS 重试失败,从而提高性能。
2. LongAdder原理-参数
LongAdder 类的父类 Striped64 有几个关键域
// 累加单元数组, 懒惰初始化,容量大小是2的n次方倍
transient volatile Cell[] cells;
// 基础值, 如果没有竞争, 则用 cas 累加这个域
transient volatile long base;
// 在 cells 创建或扩容时, 置为 1, 表示加锁
transient volatile int cellsBusy;
cas 锁:使用while循环以及一个原子类实现一个锁(cellsBusy)
@Slf4j
public class LockCas {
// 0 没加锁
// 1 加锁
private AtomicInteger state = new AtomicInteger(0);
public void lock() {
//使用compareAndSet保证一个线程修改成功之后另一个线程不能修改
while (true) {
if (state.compareAndSet(0, 1)) {
break;
}
}
}
public void unlock() {
log.debug("unlock...");
state.set(0);
}
3. 原理之伪共享
上面的三个参数中,其中 Cell 即为累加单元
@sun.misc.Contended static final class Cell {
volatile long value;
Cell(long x) { value = x; }
//最重要的方法, 用来 cas 方式进行累加, prev 表示旧值, next 表示新值
final boolean cas(long cmp, long val) {
return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
}
// 省略不重要代码
}
下面从 CPU 的缓存说起,来聊聊什么是缓存行和伪共享,下面这张图是CPU的内存结构
从上面可以看出来,CPU访问缓存行的速度是要比访问内存的速度要快的,所以在CPU访问数据的时候会把内存中的数据存储到缓存行中,然后当下次CPU再访问数据的时候就可以直接访问缓存行了,而不用到内存中去查数据,当然其中涉及到了缓存命中,以及缓存数据同步(MESI缓存一致性协议和嗅探机制),这里就不多说,在 volatile 这篇文章中有提到。
缓存以缓存行为单位,每个缓存行对应着一块内存,一般是 64 byte(8 个 long),但是有一个问题就是缓存的加入会造成数据副本的产生,即同一份数据会缓存在不同核心的缓存行中。比如 A 数据会缓存在 CPU1 中的缓存行中以及 CPU2 中的缓存行中,因为有不同的线程要操作这个数据。所以有一个规定就是CPU 要保证数据的一致性,如果某个 CPU 核心更改了数据,其它 CPU 核心对应的整个缓存行必须失效,其实这就是缓存一致性协议的内容来的。
举个例子,看下面这张图:
CPU 访问了 Cell 数组之后,会把里面的数据存入缓存行中,因为 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 的缓存行失效,失效之后再读取数据就得从主存中来读取到自己的缓存行中,这样一来,这时候效率也降低了,如果一个 CPU 频繁改,一个 CPU 频繁读,那么效率会下降不少,所以使用了 @sun.misc.Contended这个注解来解决这个问题:
它的原理是在使用此注解的对象或字段的前后各增加 128 字节大小的 padding,从而让 CPU 将对象预读至缓存时占用不同的缓存行,这样,不会造成对方缓存行的失效
,其实这个原理也被 Doug lea 用在了 JDK7 的一个队列中,这个队列也是用添加字节的方式把队首和队尾分离开来,这样当入队或者出队操作的时候就不必说把队首和队尾都锁起来。
4. 原理之累加
知道了上面 CPU 缓存的原理,下面来看看 LongAdder 类的累加 increment()
方法的流程
public void increment() {
add(1L);
}
里面主要调用了 add
方法进行调用:
public void add(long x) {
// as 为累加单元数组
// b 为基础值
// x 为累加值
Cell[] as; long b, v; int m; Cell a;
// 进入 if 的两个条件
// 1. as 有值, 表示已经发生过竞争, 进入 if
// 2. cas 给 base 累加时失败了, 表示 base 发生了竞争, 进入 if
//cells数组是懒惰创建的,竞争的时候才会创建
if ((as = cells) != null || !casBase(b = base, b + x)) {
// uncontended 表示 cell 没有竞争
boolean uncontended = true;
if (
// as 还没有创建
as == null || (m = as.length - 1) < 0 ||
// 当前线程对应的 cell 还没有被创建,a为当线程的cell
(a = as[getProbe() & m]) == null ||
// 给当前线程的 cell 累加失败 uncontended=false ( a 为当前线程的 cell )
!(uncontended = a.cas(v = a.value, v + x))
) {
// 进入 cell 数组创建、cell 创建的流程
longAccumulate(x, null, uncontended);
}
}
}
//总结:累加单元或数组创建失败或者cas累加失败了都会进入longAccumulate
add 流程图:
longAccumulate流程:
我们主要关注的是这个for循环中的三个 if 判断
第二个 else if 流程(cells数组不存在,这时候需要新建):
第一个 if流程图(cells数组已经创建好了,但是当前线程对应的累加单元cell还没被创建或者当前的cell已经创建好了)
下面这张图是第一个 if 中 cell 已经创建好了的情况,这时候就尝试累加就行了:
final void longAccumulate(long x, LongBinaryOperator fn,
boolean wasUncontended) {
int h;
// 当前线程还没有对应的 cell, 需要随机生成一个 h 值用来将当前线程绑定到 cell
if ((h = getProbe()) == 0) {
// 初始化 probe
ThreadLocalRandom.current();
// h 对应新的 probe 值, 用来对应 cell
h = getProbe();
wasUncontended = true;
}
// collide 为 true 表示需要扩容
boolean collide = false;
for (;;) {
Cell[] as; Cell a; int n; long v;
// 已经有了 cells
if ((as = cells) != null && (n = as.length) > 0) {
// 但是还没有当前线程对应的 cell
if ((a = as[(n - 1) & h]) == null) {
// 为 cellsBusy 加锁, 创建 cell, cell 的初始累加值为 x
// 成功则 break, 否则继续 continue 循环
if (cellsBusy == 0) { // Try to attach new Cell
Cell r = new Cell(x); // Optimistically create
if (cellsBusy == 0 && casCellsBusy()) {
boolean created = false;
try { // Recheck under lock
Cell[] rs; int m, j;
if ((rs = cells) != null &&
(m = rs.length) > 0 &&
// 判断槽位确实是空的
rs[j = (m - 1) & h] == null) {
rs[j] = r;
created = true;
}
} finally {
cellsBusy = 0;
}
if (created)
break;
continue; // Slot is now non-empty
}
}
// 有竞争, 改变线程对应的 cell 来重试 cas
else if (!wasUncontended)
wasUncontended = true;
// cas 尝试累加, fn 配合 LongAccumulator 不为 null, 配合 LongAdder 为 null
else if (a.cas(v = a.value, ((fn == null) ? v + x : fn.applyAsLong(v, x))))
break;
// 如果 cells 长度已经超过了最大长度(CPU核心数,超过了这个再扩容也没有意义了), 或者已经扩容, 改变线程对应的 cell 来重试 cas
else if (n >= NCPU || cells != as)
collide = false;
// 确保 collide 为 false 进入此分支, 就不会进入下面的 else if 进行扩容了
else if (!collide)
collide = true;
// 加锁
else if (cellsBusy == 0 && casCellsBusy()) {
// 加锁成功, 扩容
try {
if (cells == as) {
//扩容后的数组长度是原来的两倍
Cell[] rs = new Cell[n << 1];
//把旧数组下标的值赋值到新数组上面去
for (int i = 0; i < n; ++i)
rs[i] = as[i];
cells = rs;
}
} finally {
cellsBusy = 0;
}
collide = false;
continue; // Retry with expanded table
}
// 如果上面的失败了。证明此时这个累加单元操作不了,那么尝试改变线程对应的 cell
h = advanceProbe(h);
}
// 还没有 cells,并且没有修改了cells ,使用casCellsBusy()尝试给 cellsBusy 加锁
//下面是初始化
else if (cellsBusy == 0 && cells == as && casCellsBusy()) {
// 加锁成功, 初始化 cells, 最开始长度为 2, 并填充一个 cell
// 成功则 break;
boolean init = false;
try { // Initialize table
if (cells == as) {
//创建一个大小为2的数组
Cell[] rs = new Cell[2];
//为数组下标赋值
rs[h & 1] = new Cell(x);
//然后给cells赋值
cells = rs;
//初始化就成功了
init = true;
}
} finally {
cellsBusy = 0;
}
if (init)
break;
}
// 上两种情况失败, 尝试给 base 使用casBase累加
else if (casBase(v = base, ((fn == null) ? v + x : fn.applyAsLong(v, x))))
break;
}
}
当然了,上面的代码看看图了解思想,大概先知道工作流程,等以后再深究也可以。
sum流程:
上面的 longAccumulate 执行完成后,下面就使用 sum 方法把每个cell 单元的数据累加起来:
public long sum() {
//获取已经创建并赋值好的cells数组
Cell[] as = cells; Cell a;
long sum = base;
if (as != null) {
//循环遍历数组
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
//添加
sum += a.value;
}
}
//返回结果
return sum;
}
8. Unsafe
1. 获取 unsafe
Unsafe 对象提供了非常底层的,操作内存、线程的方法,Unsafe 对象不能直接调用,只能通过反射获得。在之前的原子整性 AtomicInteger 类中,使用的方法就基本都是 Unsafe 提供的。提一句:Unsafe 不是说线程不安全的意思。
public class UnsafeAccessor {
static Unsafe unsafe;
static {
try {
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;
}
}
我们到这个类中去查看为什么不能直接创建,只需要看变量和构造器就行了:
private static final Unsafe theUnsafe;
/*
中间省略一堆变量
*/
private static native void registerNatives();
private Unsafe() {
}
可以看到本身就是一个私有构造器,所以没办法 new,上面提供了一个变量 theUnsafe
,我们可以反射获取到这个变量。当然了查看 AtomicInteger 的源码可以发现AtomicInteger
这个类获取到 Unsafe 对象是通过 Unsafe 类中的一个静态方法获取的。可以看到,其实最终返回的也是开头定义的那个 theUnsafe 对象。
@CallerSensitive
public static Unsafe getUnsafe() {
Class var0 = Reflection.getCallerClass();
if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
throw new SecurityException("Unsafe");
} else {
return theUnsafe;
}
}
2. Unsafe CAS 操作
里面涉及到偏移地址的知识,在 JVM 中有说。
public class TestUnsafe {
public static void main(String[] args) throws Exception {
Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
theUnsafe.setAccessible(true);
//静态变量不需要传值进去get
Unsafe unsafe = (Unsafe)theUnsafe.get(null);
//1. 获取到域的偏移地址,通过偏移地址来找到最终的地址
long idOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("id"));
long nameOffset = unsafe.objectFieldOffset(Teacher.class.getDeclaredField("name"));
//2. 执行CAS
Teacher teacher = new Teacher();
//参数:操作的对象 域的偏移值 原来的id值 修改后的id值
unsafe.compareAndSwapInt(teacher, idOffset, 0, 1);
unsafe.compareAndSwapObject(teacher, nameOffset, null, "张三");
System.out.println(teacher);//Teacher(id=1, name=张三)
}
}
@Data
class Teacher{
volatile int id;
volatile String name;
}
3. Unsafe 自定义一个原子整数类
class MyAutomicInteger implements Account{
public static void main(String[] args) {
Account.demo(new MyAutomicInteger(10000));
}
//初始化操作
private volatile int value;
private static final long valueOffset;
static final Unsafe UNSAFE;
static{
try {
//调用 Unsafe 中的静态方法获取 Unsafe 对象
UNSAFE = UnsafeAccessor.getUnsafe();
//获取到 value 的偏移值
valueOffset = UNSAFE.objectFieldOffset(MyAutomicInteger.class.getDeclaredField("value"));
} catch (NoSuchFieldException e) {
e.printStackTrace();
throw new RuntimeException(e);
}
}
//给value赋初始值
public MyAutomicInteger(int value) {
this.value = value;
}
//返回value
public int getValue(){
return value;
}
//CAS去减少
public void decrement(int amount){
while(true){
int prev = this.value;
int next = prev - amount;
if(UNSAFE.compareAndSwapInt(this, valueOffset, prev, next)){
break;
}
}
}
@Override
public Integer getBalance() {
return getValue();
}
@Override
public void withdraw(Integer amount) {
decrement(amount);
}
}
输出结果:
如有错误,欢迎指出!!!