关键词：
文章目录
并发编程-5-共享模型之无锁
本文章视频指路👉黑马程序员-并发编程
1.无锁解决线程安全问题
有如下需求，保证 account.withdraw 取款方法的线程安全：
interface Account
// 获取余额
Integer getBalance();
// 取款
void withdraw(Integer amount);
/**
* 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
* 如果初始余额为 10000 那么正确的结果应当是 0
*/
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");
原有实现并不是线程安全的：
class AccountUnsafe implements Account
private Integer balance;
public AccountUnsafe(Integer balance)
this.balance = balance;
@Override
public Integer getBalance()
return balance;
@Override
public void withdraw(Integer amount)
this.balance -= amount;
执行测试代码：
public static void main(String[] args)
Account.demo(new AccountUnsafe(10000));
某次得到的结果：
330 cost: 306 ms
解决办法-锁
首先想到的是给 Account 对象加锁：
@Override
public synchronized void withdraw(Integer amount)
balance -= amount;
解决思路-无锁
class AccountCas implements Account
private AtomicInteger balance;
public AccountCas(int balance)
this.balance = new AtomicInteger(balance);
@Override
public Integer getBalance()
return balance.get();
@Override
public void withdraw(Integer amount)
while (true)
int prev = balance.get();
//要修改的余额
int next = prev - amount;
//把next同步到主存，如果成功退出循环，不成功说明有其他线程已经修改了amount，此时需要重新写入
if (balance.compareAndSet(prev, next))
break;
// 可以简化为下面的方法
// balance.addAndGet(-1 * amount);
2.CAS 与 volatile
2-1 CAS
前面看到的 AtomicInteger 的解决方法，内部并没有用锁来保护共享变量的线程安全。那么它是如何实现的呢？
public void withdraw(Integer amount)
while(true)
// 需要不断尝试，直到成功为止
while (true)
// 比如拿到了旧值 1000
int prev = balance.get();
// 在这个基础上 1000-10 = 990
int next = prev - amount;
/*
compareAndSet 正是做这个检查，在 set 前，先比较 prev 与当前值
- 不一致了，next 作废，返回 false 表示失败
比如，别的线程已经做了减法，当前值已经被减成了 990
那么本线程的这次 990 就作废了，进入 while 下次循环重试
- 一致，以 next 设置为新值，返回 true 表示成功
*/
if (balance.compareAndSet(prev, next))
break;
其中的关键是 compareAndSet，它的简称就是 CAS （也有 Compare And Swap 的说法），它必须是原子操作。
注意：
- 其实 CAS 的底层是
lock cmpxchg指令（X86 架构），在单核 CPU 和多核 CPU 下都能够保证【比较-交换】的原子性。- 在多核状态下，某个核执行到带 lock 的指令时，CPU 会让总线锁住，当这个核把此指令执行完毕，再开启总线。这个过程中不会被线程的调度机制所打断，保证了多个线程对内存操作的准确性，是原子的。
2-2 volatile
- 获取共享变量时，为了保证该变量的可见性，需要使用
volatile修饰。 - 它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取 它的值，线程操作
volatile变量都是直接操作主存。即一个线程对volatile变量的修改，对另一个线程可见。
注意：
volatile仅仅保证了共享变量的可见性，让其它线程能够看到新值，但不能解决指令交错问题（不能保证原子性）
CAS 必须借助 volatile 才能读取到共享变量的新值来实现【比较并交换】的效果
2-3 为什么无锁效率高
一般情况下，使用无锁比使用加锁的效率更高
- 无锁情况下，即使重试失败，线程始终在高速运行，没有停歇，而
synchronized会让线程在没有获得锁的时候，发生上下文切换，进入阻塞。 - 但无锁情况下，因为线程要保持运行，需要额外 CPU 的支持，CPU 在这里就好比高速跑道，没有额外的跑道，线程想高速运行也无从谈起，虽然不会进入阻塞，但由于没有分到时间片，仍然会进入可运行状态，还是会导致上下文切换。
2-4 CAS特点
结合 CAS 和 volatile 可以实现无锁并发，适用于线程数少、多核 CPU 的场景下。
CAS是基于乐观锁的思想：乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试呗。synchronized是基于悲观锁的思想：悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会。- CAS 体现的是无锁并发、无阻塞并发
- 因为没有使用 synchronized，所以线程不会陷入阻塞，这是效率提升的因素之一
- 但如果竞争激烈，可以想到重试必然频繁发生，反而效率会受影响
3.原子整数
J.U.C 并发包提供了：
AtomicBooleanAtomicIntegerAtomicLong
以 AtomicInteger 为例：
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));
4.原子引用
4-1 原子引用的使用
为什么需要原子引用类型？
AtomicReferenceAtomicMarkableReferenceAtomicStampedReference
有如下方法：
public interface DecimalAccount
BigDecimal getBalance();
void withdraw(BigDecimal amount);
/**
* 方法内会启动 1000 个线程，每个线程做 -10 元 的操作
* 如果初始余额为 10000 那么正确的结果应当是 0
*/
static void demo(DecimalAccountImpl account)
List<Thread> ts = new ArrayList<>();
long start = System.nanoTime();
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();
);
long end = System.nanoTime();
System.out.println(account.getBalance() + " cost: " + (end - start) / 1000_000 + " ms");
class DecimalAccountImpl implements DecimalAccount
//原子引用，泛型类型为小数类型
AtomicReference<BigDecimal> balance;
public DecimalAccountImpl(BigDecimal balance)
this.balance = new AtomicReference<BigDecimal>(balance);
@Override
public BigDecimal getBalance()
return balance.get();
@Override
public void withdraw(BigDecimal amount)
while(true)
BigDecimal pre = balance.get();
BigDecimal next = pre.subtract(amount);
if(balance.compareAndSet(pre, next))
break;
public static void main(String[] args)
DecimalAccount.demo(new DecimalAccountImpl(new BigDecimal("10000")));
4-2 ABA 问题及解决
ABA问题
因为CAS需要在操作值的时候，检查值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加1，那么A→B→A就会变成1A→2B→3A
从 Java 1.5开始，JDK的Atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法的作用是首先检查当前引用是否等于预期引用，并且检查当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值
AtomicStampedReference
@Slf4j
public class Test3
static AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
public static void main(String[] args)
log.debug("main start...");
// 获取值 A
String prev = ref.getReference();
// 获取版本号
int stamp = ref.getStamp();
log.debug("版本 ", stamp);
// 如果中间有其它线程干扰，发生了 ABA 现象
other();
sleep(1);
// 尝试改为 C
log.debug("change A->C ", ref.compareAndSet(prev, "C", stamp, stamp + 1));
private static void other()
ref.compareAndSet(ref.getReference(), "B", ref.getStamp(), ref.getStamp() + 1);
ref.compareAndSet(ref.getReference(), "A", ref.getStamp(), ref.getStamp() + 1);
22:48:31 DEBUG [main] (Test3.java:16) - main start...
22:48:31 DEBUG [main] (Test3.java:21) - 版本 0
22:48:32 DEBUG [main] (Test3.java:26) - change A->C false
AtomicStampedReference 可以给原子引用加上版本号，追踪原子引用整个的变化过程，如： A -> B -> A -> C ，通过AtomicStampedReference，我们可以知道，引用变量中途被更改了几次。
但是有时候，并不关心引用变量更改了几次，只是单纯的关心是否更改过，所以就有了 AtomicMarkableReference
AtomicMarkableReference
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;
@Slf4j
public class TestABAAtomicMarkableReference
public static void main(String[] args) throws InterruptedException
GarbageBag bag = new GarbageBag("装满了垃圾");
// 参数2 mark 可以看作一个标记，表示垃圾袋满了
AtomicMarkableReference<GarbageBag> ref = new AtomicMarkableReference<>(bag, true);
log.debug("主线程 start...");
GarbageBag prev = ref.getReference();
log.debug(prev.toString());
new Thread(() ->
log.debug("打扫卫生的线程 start...");
bag.setDesc("空垃圾袋");
while (!ref.compareAndSet(bag, bag, true, false))
log.debug(bag.toString());
).start();
Thread.sleep(1000);
log.debug("主线程想换一只新垃圾袋？");
boolean success = ref.compareAndSet(prev, new GarbageBag("空垃圾袋"), true, false);
log.debug("换了么？" + success);
log.debug(ref.getReference().toString());
22:50:57 DEBUG [main] (Test5.java:14) - start...
22:50:57 DEBUG [main] (Test5.java:16) - xpp.day3.GarbageBag@ffa5d 装满了垃圾
22:50:57 DEBUG [保洁阿姨] (Test5.java:18) - start...
22:50:57 DEBUG 查看详情
帮你快速拿offer！dockerpull本地
三大内容：Java并发编程Java高并发编程高并发系统设计Java并发编程1.概览2.进程与线程3.Java线程4.共享模型之管程5.共享模型之内存6.共享模型之无锁7.共享模型之不可变8.共享模型之工具并发编程—模式篇：并发编程—应用... 查看详情
高并发编程之无锁(代码片段)
...的一些基础用法以及通过jvm内存模型的方式去介绍了一些并发中常见的问题（想看往期文章的小伙伴可以直接拉到文章最下方飞速前往）。本文重点介绍一个概念“无锁”本期精彩什么是无锁无锁类的原理AtomicIntegerUnsafeAto... 查看详情
并发编程（学习笔记-共享模型之内存）-part4(代码片段)
文章目录并发编程-4-共享模型之内存1.Java内存模型2.可见性2-1退不出的循环2-2可见性vs原子性3.有序性3-1诡异的结果3-2解决方法3-3有序性理解3-4happens-before4.volatile原理4-1如何保证可见性4-2如何保证有序性4-3double-checkedlocking问题并发... 查看详情
并发编程（学习笔记-共享模型之管程）-part3(代码片段)
文章目录并发编程-共享模型之管程-31.共享带来的问题1-1临界区CriticalSection1-2竞态条件RaceCondition2.synchronized解决方案2-1解决方案2-2synchronized的使用2-3方法上的synchronized3.变量的线程安全分析3-1成员变量和静态变量是否线程安全ÿ... 查看详情
java基础语法测试题和答案，看这篇足矣了！
三大内容：Java并发编程Java高并发编程高并发系统设计Java并发编程1.概览2.进程与线程3.Java线程4.共享模型之管程5.共享模型之内存6.共享模型之无锁7.共享模型之不可变8.共享模型之工具并发编程—模式篇：并发编程—应用... 查看详情
交易系统开发技能及面试之无锁编程（lock-free）(代码片段)
...享问题，最常用的方式就是加锁了，这在上一章并发编程也讲到过很多。关于无锁的时候，也写过一篇无锁队列的实现，而今天这篇文章主要是讲解无锁编程所需要了解的基础知识，比如atomics，内存模型&#... 查看详情
并发之无锁技术归纳(代码片段)
并发之AtomicBoolean/AtomicBooleanArray/AtomicBooleanUpdateFeild1 和前面的AtomicInteger很相似或者原理基本一致的；原理就是使用了CAS算法实行循环重试的方式来保证一组操作是原子性的操作；2 同样的也是一个无锁技术的应用；3 ... 查看详情
多线程编程之无锁队列
关于无锁队列的概念与实现，可以参考博文《无锁队列的实现》，主要涉及到的知识点包括CAS原子操作、无锁队列的链表实现、无锁队列的数组实现以及ABA问题。 下面借鉴了《多线程的那点儿事（之无锁队列）》的代码，说... 查看详情
java岗大厂面试官常问的那些问题，面试突击版！
并发编程共享模型篇并发编程概览进程与线程Java线程共享模型之管程共享模型之内存共享模型之无锁共享模型之不可变共享模型之工具共享模型之管程原理之Monitor(锁)原理之伪共享模式篇—正确姿势同步模式之保护性智停同步... 查看详情
volatile学习笔记(代码片段)
...型(JMM)及volatile关键字正确使用Volatile变量Java内存模型在并发编程中，需要处理两个关键问题：线程之间如何通信及线程之间如何同步。通信是指线程之间以何种机制来交换信息。同步是指程序中用于控制不同线程间操作发生相... 查看详情
java并发编程：管程内存模型无锁并发线程池aqs原理与锁线程安全集合类并发设计模式
文章目录基础1.进程与线程2.并发与并行3.同步与异步4.主线程与守护线程5.Thread与Runnable6.线程方法7.线程状态管程1.共享问题、临界区、竞态条件2.Monitor3.synchronized4.wait¬ify5.Park&Unpark6.活跃性7.ReentrantLock8.lockvssynchronized内存... 查看详情
java并发编程：管程内存模型无锁并发线程池aqs原理与锁线程安全集合类并发设计模式(代码片段)
文章目录基础1.进程与线程2.并发与并行3.同步与异步4.主线程与守护线程5.Thread与Runnable6.线程方法7.线程状态管程1.共享问题、临界区、竞态条件2.Monitor3.synchronized4.wait¬ify5.Park&Unpark6.活跃性7.ReentrantLock8.lockvssynchronized内存... 查看详情
juc并发编程--保护共享资源（加锁实现&无锁实现）(代码片段)
1.保护共享资源1.1不安全的实现:账户接口:interfaceAccount//获取余额IntegergetBalance();//取款voidwithdraw(Integeramount);/***方法内会启动1000个线程，每个线程做-10元的操作*如果初始余额为10000那么正确的结果应当是0*/staticvoiddemo(Accountacco... 查看详情
c++并发编程----无锁实现线程安全队列（《c++concurrencyinaction》读书笔记）(代码片段)
采用计数器的方式防止条件竞争。template<typenameT>classlock_free_queueprivate:structnode;structcounted_node_ptrintexternal_count;//记录外部线程通过指针的引用node*ptr;;std::atomic<counted_node_ptr>head;std::atomic<c 查看详情
java并发编程：管程内存模型无锁并发线程池aqs原理与锁线程安全集合类并发设计模式(代码片段)
文章目录基础1.进程与线程2.并发与并行3.同步与异步4.主线程与守护线程5.Thread与Runnable6.线程方法7.线程状态管程1.共享问题、临界区、竞态条件2.Monitor3.synchronized4.wait¬ify5.Park&Unpark6.活跃性7.ReentrantLock8.lockvssynchronized内存... 查看详情
redis学习笔记29——无锁的原子操作：redis如何应对并发访问(代码片段)
为了保证并发访问的正确性，Redis提供了两种方法，分别是加锁和原子操作。但是加锁会遇到两个问题：首先是加锁操作过多会降低系统的并发访问性能其次，Redis客户端要加锁时，需要使用分布式锁，而... 查看详情
redis学习笔记29——无锁的原子操作：redis如何应对并发访问(代码片段)
为了保证并发访问的正确性，Redis提供了两种方法，分别是加锁和原子操作。但是加锁会遇到两个问题：首先是加锁操作过多会降低系统的并发访问性能其次，Redis客户端要加锁时，需要使用分布式锁，而... 查看详情