网站跨机房建设方案,北京网站优化开户,国外免费做网站软件,做ug图纸的网站文章目录 CAS 与 volatile慢动作分析volatile为什么无锁效率高CAS 的特点 原子整数原子引用不安全实现安全实现-使用锁安全实现-使用 CAS CAS 与 volatile
在java并发编程七六中#xff0c;可以看到的 AtomicInteger 的解决方法#xff0c;内部并没有用锁来保护共享变量的线… 文章目录 CAS 与 volatile慢动作分析volatile为什么无锁效率高CAS 的特点 原子整数原子引用不安全实现安全实现-使用锁安全实现-使用 CAS CAS 与 volatile
在java并发编程七六中可以看到的 AtomicInteger 的解决方法内部并没有用锁来保护共享变量的线程安全。那么它是如何实现的呢
public void withdraw(Integer amount) {while(true) {// 需要不断尝试直到成功为止
while (true) {// 比如拿到了旧值 1000int prev balance.get();// 在这个基础上 1000-10 990int next prev - amount;/*compareAndSet 正是做这个检查在 set 前先比较 prev 与当前值- 不一致了next 作废返回 false 表示失败
比如别的线程已经做了减法当前值已经被减成了 990
那么本线程的这次 990 就作废了进入 while 下次循环重试- 一致以 next 设置为新值返回 true 表示成功
*/
if (balance.compareAndSet(prev, next)) {break;}}}}其中的关键是 compareAndSet它的简称就是 CAS 也有 Compare And Swap 的说法它必须是原子操作。
慢动作分析
Slf4jpublic class SlowMotion {public static void main(String[] args) {AtomicInteger balance new AtomicInteger(10000);int mainPrev balance.get();log.debug(try get {}, mainPrev);new Thread(() - {sleep(1000);int prev balance.get();balance.compareAndSet(prev, 9000);log.debug(balance.toString());},
t1).start();sleep(2000);log.debug(try set 8000...);boolean isSuccess balance.compareAndSet(mainPrev, 8000);log.debug(is success ? {}, isSuccess);if(!isSuccess){mainPrev balance.get();log.debug(try set 8000...);isSuccess balance.compareAndSet(mainPrev, 8000);log.debug(is success ? {}, isSuccess);}}private static void sleep(int millis) {try {Thread.sleep(millis);}
catch (InterruptedException e) {e.printStackTrace();}}}输出结果
2023-10-13 11:28:37.134 [main] try get 10000
2023-10-13 11:28:38.154 [t1] 9000
2023-10-13 11:28:39.154 [main] try set 8000...
2023-10-13 11:28:39.154 [main] is success ? false
2023-10-13 11:28:39.154 [main] try set 8000...
2023-10-13 11:28:39.154 [main] is success ? true volatile
获取共享变量时为了保证该变量的可见性需要使用 volatile 修饰。 它可以用来修饰成员变量和静态成员变量他可以避免线程从自己的工作缓存中查找变量的值必须到主存中获取它的值线程操作 volatile 变量都是直接操作主存。即一个线程对 volatile 变量的修改对另一个线程可见。
CAS 必须借助 volatile 才能读取到共享变量的最新值来实现【比较并交换】的效果
为什么无锁效率高
无锁情况下即使重试失败线程始终在高速运行没有停歇而 synchronized 会让线程在没有获得锁的时候发生上下文切换进入阻塞。打个比喻线程就好像高速跑道上的赛车高速运行时速度超快一旦发生上下文切换就好比赛车要减速、熄火等被唤醒又得重新打火、启动、加速… 恢复到高速运行代价比较大但无锁情况下因为线程要保持运行需要额外 CPU 的支持CPU 在这里就好比高速跑道没有额外的跑道线程想高速运行也无从谈起虽然不会进入阻塞但由于没有分到时间片仍然会进入可运行状态还是会导致上下文切换。
CAS 的特点
结合 CAS 和 volatile 可以实现无锁并发适用于线程数少、多核 CPU 的场景下。
CAS 是基于乐观锁的思想最乐观的估计不怕别的线程来修改共享变量就算改了也没关系我吃亏点再重试呗。synchronized 是基于悲观锁的思想最悲观的估计得防着其它线程来修改共享变量我上了锁你们都别想改我改完了解开锁你们才有机会。CAS 体现的是无锁并发、无阻塞并发请仔细体会这两句话的意思 因为没有使用 synchronized所以线程不会陷入阻塞这是效率提升的因素之一但如果竞争激烈可以想到重试必然频繁发生反而效率会受影响
原子整数
J.U.C 并发包提供了
AtomicBooleanAtomicIntegerAtomicLong
以 AtomicInteger 为例
AtomicInteger i new AtomicInteger(0);// 获取并自增i 0, 结果 i 1, 返回 0类似于 iSystem.out.println(i.getAndIncrement());// 自增并获取i 1, 结果 i 2, 返回 2类似于 iSystem.out.println(i.incrementAndGet());// 自减并获取i 2, 结果 i 1, 返回 1类似于 --iSystem.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 中因此不必是 finalSystem.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));原子引用
为什么需要原子引用类型
AtomicReferenceAtomicMarkableReferenceAtomicStampedReference
有如下方法
public interface DecimalAccount {// 获取余额
BigDecimal getBalance();// 取款
void withdraw(BigDecimal amount);/*** 方法内会启动 1000 个线程每个线程做 -10 元 的操作
* 如果初始余额为 10000 那么正确的结果应当是 0*/static void demo(DecimalAccount account) {ListThread ts new ArrayList();for (int i 0; i 1000; i) {ts.add(new Thread(() - {account.withdraw(BigDecimal.TEN);}));}ts.forEach(Thread::start);ts.forEach(t - {try {t.join();} catch (InterruptedException e) {e.printStackTrace();}});System.out.println(account.getBalance());}}
试着提供不同的 DecimalAccount 实现实现安全的取款操作
不安全实现
class DecimalAccountUnsafe implements DecimalAccount {BigDecimal balance;public DecimalAccountUnsafe(BigDecimal balance) {this.balance balance;}Overridepublic BigDecimal getBalance() {return balance;}Overridepublic void withdraw(BigDecimal amount) {BigDecimal balance this.getBalance();this.balance balance.subtract(amount);}}安全实现-使用锁
lass DecimalAccountSafeLock implements DecimalAccount {private final Object lock new Object();BigDecimal balance;public DecimalAccountSafeLock(BigDecimal balance) {this.balance balance;}Overridepublic BigDecimal getBalance() {return balance;}Overridepublic void withdraw(BigDecimal amount) {synchronized (lock) {BigDecimal balance this.getBalance();this.balance balance.subtract(amount);}}}安全实现-使用 CAS
class DecimalAccountSafeCas implements DecimalAccount {AtomicReferenceBigDecimal ref;public DecimalAccountSafeCas(BigDecimal balance) {ref new AtomicReference(balance);}Overridepublic BigDecimal getBalance() {return ref.get();}Overridepublic void withdraw(BigDecimal amount) {while (true) {BigDecimal prev ref.get();BigDecimal next prev.subtract(amount);if (ref.compareAndSet(prev, next)) {break;}}}}测试代码
DecimalAccount.demo(new DecimalAccountUnsafe(new BigDecimal(10000)));DecimalAccount.demo(new DecimalAccountSafeLock(new BigDecimal(10000)));DecimalAccount.demo(new DecimalAccountSafeCas(new BigDecimal(10000)));运行结果
4310 cost: 425 ms
0 cost: 285 ms
0 cost: 274 ms
