Github架构师解读C/C++应用包管理的Why和How
来源：
https://blog.biezhi.me/2019/01/head-first-cas.html
后端开发中大家肯定遇到过实现一个线程安全的计数器这种需求，根据经验你应该C # A J知道我们要在多线程中实现 共享变量 的原子性和可见性问 F / R $题，于是锁成为一个不可避免的话题，今天我们讨论的是与之对应的无锁 CASq ? F D b e I J。本文会~ ` T ] $ b从怎么来的、是什么、怎么用、原理分析、遇到的问题等不同的角度带你真正搞懂 CAS。
为什么要无锁
我们一想到在多线程下保证安全的方式头一个要拎出来的肯定是锁，不管从硬件、操作系统层面都或多或少在使用锁。锁有什么缺点吗s P j /？当然有了，不然 JDK 里为什么出现那么多各式各样的锁，就是因为每一W 2 v T ~ $种锁都有其优劣势。
使用锁就需要 / ? m %获. l s得锁、释放锁，CPU 需要通过上下文切换和调度管理来进行这个操作，对于一个 独占锁 而言一个线程在持有锁后没执行结束其他的哥们就必须在外面等着，等到前面的哥们执行完毕 C$ r rPU 大哥就会把锁拿出来其他的线程来$ 6 ) a D抢了（非J t T w & # f V公平）。锁的这种概念基于一种悲观机制，它总是认为数据会被修改，所以你在操作一部分代码块之前先加一把锁，操作完毕后再释放，l : D z Z C s这样就安全了。其实在 JDK1.5 使用 synchronized 就可以做到。
但是像上面的操作在多线程下会让 CPU 不断的切换，非常消耗资源，我们知道可以使用具体的某一类锁来避免部分问题。那除了锁的方式还有其他G J | (的吗？当然，有人就提出了无锁算法，比较有名的就是我们今天要说的 CAV 4 )S（compare and swap），和锁不同的是它是一种乐观的机制，它认为别人去拿数据的时候不会修改，但是在修改数据的时候去判断一下数据此时的状态，这样的话 CPU 不会切换，在读多的情况下性能将得到大幅提升。当前我们使用的大部分 CPM t 2U 都有 CAS 指令了，7 r ! q ] 1 , H )从硬件层面支持无锁，这样开发的时候去调E 8 7 Q b : z r #用就可以了。
不论是 t Frvice = Executors.newCacheh H @dThreadPool();
2 AtomicInteger atomi0 kcIntegr M S %er = new AtomicInteger(0);
3
4 foW * I X ) @r (int i = Y w V O q;0;&nbA o * % h I 4sp;i < 0 K l5000; i++) {
5 executorService.execute(atomicInteger::incremv + I 9 :entAndGet);
6 }
7
8 System.out.a M a v ; = n lprintln(aM D z a YtomicInteger.get());) p C
9 executorService.shuR ; [ y R 6tdown();
这个例子开启了 5000 个线程去进行累加操作，不管你执行多少次答案都是 5000。这么神奇的操作是如何实现的呢？就是依靠 CAS 这种技术来完成的，我们揭开 AtomicInteger 的老底看看它的代码：
1pub) S G 8 1lic&n| 8 T Dbsp;classf d _ AtomicInteger e* w 8 H Q * , *xtends Number implT U ! Uements java.io.Serializable {
2 private static final long se{ 9 ! _ 7 brialVersionUID = 6214790243416807050L;
3
4 // setup&nbsz A U J C : op;to um R 4sG q / N Ve UnsafF I me.compareAndSwapInt&nbc ~ fsp;for updates
5 private static&nm ? |bsp;N 0 x r O J I :final Unsafg k @ s q C 2 2e , , = 1 %unsafe =Q J + { L f x Unsafe.getUnsafe();
6 &nbs0 v dp; private stT } R M + 7 K Ratic final long valueOffseti g L;
7
8 static ~ M q E {
9 &nbs8 4 |p; N d ztry {
10 valueOffset = unsafe.objectFieldOffset
11 V [ ) ^ n &nb: C / Q r a Jsp; &n% , p T O p D (AtomicInteger.class.getDeclaredField(\"valup y Z % 5 , z O :e\"));
12 . ] P h t + } catch (9 p eException ex) { throw new Error(ex); }
13 d A r * }
14
15 private volatile int value;
16
17 /**
19 ; } a8 * Creates a nX { 1 } tew AtomicInteger with the given initial value.
19&nb5 4 T q $ [sp;P j ! i ^ c &nbN O 6 v 1sp;*
20 * @param initialValue the initial value
21 &nbss # U ? J , ~p;*/
22&nS q h = Jbsp; public AtomicInteger(int initialValue) {
23 &; Y Znbsp; value = initialValue;
24 S B I * B = j }
25
26&nb k h , k 0 E bsp;&nb8 * ` k ~ e P g jsp; /**
27 * Gets the&nbsa m % , ,p;current value.
28 &nbs0 3 9p; k C Y x q U # + y;*
29 &nbse ~ . @ H % ; i fp; * u 8 M } 8 4 D Y S;@return the current value
30 l N s */
31 &nbx ? ^sp; public final int get() {
32 &nb_ B s 1 f ) 5sp; return value;
33 &nb- 7 R C r Asp; }
34
35 Y N p L 0&nb_ 3 H / I . K t qsp;4 9 X /**
36 &Q } i fnu w o l c x +bsp; * Atomically increments bV ?y&nc N U R , f [bsp;one the current value.
37 &A g d H # o :nbsp; *
38 * @return the ` A _ (updk J $ B | - % Mated value
39 */
40 public final int increme( r v E UntAndGet() {
41 &r S 2 i m j #nbsp; &n^ 0 x Ibsp;return unsafe.getAndAddInt(this, valuP U F $eOffset, 1) + 1;
42&nb Ct 方法。Unsafe 这个类是 JDK 提供的一个比较底层的类，它不让我们程序员直接使用，主 w I ] , h n要是怕操作不当把机器玩坏了。。。v k g Q / U（其实可以通过反射的方式获取到这个类的实例）你会在 JDK 源码的很多地方看到这家伙，我们先说说它有什么能力：- 内存管理：包括分配内存、释放内存
- 操作类、对象、变量：通过获取对象和变量偏移量直接修改数据
- 挂起与恢复：将线程阻塞或者恢复阻塞状态
- CAS：调用 CPU 的 CAS 指令进行比较和交换n { , k S d
- 内存屏障：定义内存屏障，避免指令重排序
这里只是大致提一下常用的操作，具体细节可以在文末的参考链接中查看。下面我们继续看 unsafe 的 g_ j j ! W 1etAndAddInt 在做什么。
1public final i! J $ J 0 T M 0nt R * t ) O JgetAndAddInt(Object var1,&nbs9 % o m ` 0 yp;long var2, int var4) {
2 int var5;
3 &nbsv O v # ; Z : 3 *p% Z *; do {
4 var5 = thp m l Y I A o K =is.getIntVolatile(var1, var2);
5 } while(!this.compart T DeAndSwapInt5 K N 7 I z ) *(var1, var2, var5, var5 + var4));
6
7 return var5;
8}
9
10public nativ{ $ fe int getIntVolatile(Object var1, long% Y R y y vas i V 6r2);
11public final native&nbs Q / S p;b@ + z I o g b !oolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
其实很简单，先通过 getIntVolatile 获取到内存的当前值，然后进行比较，展开 compareAndSwapInt 方法的几个参数：
- var1: 当前要操作的Z G H @ b B 2 L b ratic&n^ N t / $ sbsp;final Unsafe unsafe = x Unsafe.getUnsafe();
3private static final long@ e 2 i G K&nbB l N r _ z - Nsp;valueOffset;
4
5static {
6 try P N 4 @ T B t;{
7 valueOffset = unsafe.objectFieldOffset
8 &nbsN n 7p; &ng 9 , U o 1 / (bsp; &nbs/ ^ N | $ I q 7p; (AtomicInteger.class.getDeclZ } Z y Z 5 x / VaredField(\"value\"));
9 } catM [ v ^ 8 ) r O Pch (Exception&nb 1 - {sp;ex) {&nbB 4 H 1 Z O B ;sp;throw new Errou D E D 0 ( K Z nr(ex); }
10}
11
12pri: K & = Ovate volatile int vj q M a y a L r !alue;
可以看出在静态代码块执行的时候将 AtomicInteger 类的 value 这个字段的偏移量获取出来，拿@ 2 G ; `这个 long 数据干嘛呢？在 Unsafe 类里很多地方都需要传入 obj 和偏移量，结合我们说 UnsafeX E * & l 的诸多能力，其实就是直接通过更底层的方式将对象字段在内存的数据修改掉。
使用上面的方式就可以很好的解决多线( O . E x ^ n B程下的原子性和可见性问题。由于代码里使用了 do while 这种循环结构，所以 CPU 不会被挂起，比C = D % ` 0 B L较失败后重试，就不存在上下文切换了，实现了无锁并发编程。
CAS 存在的问题
自旋的劣势
你留意上面的代码会发现一个问题，while 循环如果在最坏情况下总是失败怎么办？会导致 CPU 在不断处理。像这种 while(!compareAndSwapInt) 的操作我们称之为自旋，CAS 是乐观的，认为大家来并不都是修改数据的，现实可能出现g V m 4 - Z @非常多的线程过来都要修改这个数据，此时随j w S f _着并发量的增加会导致 CA. R p X 8S 操作长时间不成功，CPU 也会有很大的开销。所以我们要清楚，如果是读多写少的情况也就满足乐观，性能是非常好的。
ABA 问题
提到 CAS 不得不说 ABA 问题，它S U E R ; N Y c是说假如内存的值原来是 A，被一个线程修改为了 B，此时又有一个线程把它修改为了 A，那么 CAS 肯定是操作成功的。真的这样做的话代码J L ! B可能就有 bug 了，对于修改数据为 B 的那个线程它应该读取到 B 而不[ @ o { 9是 A，如果你做过数据库相关的乐观锁机制可能会想到我们在比较的时候使用一个版本号 version 来进行判断就可以搞定。在 JDKX ` / ~ 里提供了V Y x { b ` !一个 AtomN 6 !icStampedReference 类来解决这个问题，来看一个例子：
1int sta# } 6 h Rmp = 10001;
2
3AtomicStampedReference<Ib % R ) A A mnteger>&g m } | H -nbsp;stampedRefd K Y &erence = neO ) t { d 4 V 6 Pw AtomicStampedReference<>(0, stamp);
4q 0 * D K
5stampedReference.compareAndSet(0, 10, stamp, stamp + 1);
6
7System.out.println(\"value: \" + stams H / l )pedReference.getReference());
8System.out.println(\"stamp: \" + stampedReference.getStamp());它的构造函数是 2 个参数，多传入了一个初始 时间戳，用这个戳来给数据加了一个版本，这样的话多个线G B E @ 7 | n Q 3程来修改如果提供= t } L的戳不同。在修改数据的时候除了提供一个新的值u ? c之外还要提供j 3 a Y 8 6 u #一个新的戳，这样在多线程情况下只要数~ 8 a k据被修改了那3 v [ V S n D 4 z么戳一2 r F 4 定会发生改变，另一个线程拿到的是旧的戳所以会修改失败。
尝试应用
既然z t 6 L CAS 提供了这么好的 API，我们不妨用它来实现一个简易版的独占锁。思路是当某个线程进入 lock 方法就比较锁对象的内存值是否是 false，如果是则代表这把锁它可以获取，获取后将内存之修改为 true，获取不到就自旋。在 unlock 的时候将内存值再修改为 false 即可，代码如下：
1public cla^ * 0 f {ss SpinLock {
2
3 P n 4 q; private AtomicBoolea# ` d * l an&nbx # G . 7 s l 5sp;mutex = new AtomicBoolea[ o Y d g |n(false);
4
5 public void lock()&@ i e ;nbsp;{
6 &np Y ?bs. 6 W f d m ;p; while (!mutex.compareAndSet(false, true)) {
7@ 9 # + . +&nbs0 = g Z m Sp; // System.out.println(Thread.currentThread().getName()+y # Q \" wait lock release\");
8 }
9 }
10
11 public void 6 x w z;unlock() {
12 &nbK 4 9 . 0sp; &no R 0 obsp; while F m + C t V . f;(!mutex.compareAndSet(true, false)) {
13 // System.out.println(Thread.curU 5 + ? UrentThread().getName()+ \" wait loR W ? B n hck release\");
14 &nb8 $ I $ S E i i dsp; }
15 }
16
17}这里M F 7 etx [ 3, jint e, jint&nbh B k V b Q 8 Dsp;x))
2 UnsafeWrapper(\"U[ Q Ensafe_CompareAndSwapInt\")~ Y w V M & _p;//&nG b G ) 6 W . Gbsp;执行一个原子操作
7 // 如果结果和现在不同，就直` W X &接返回，因为有其他u ] | | u人修改了；否则会一直尝试去修改。C E Q A q {直到成功。
8 return (jint)/ Z K R I B i(Atomico b r . q i G r P::cmpxchg(x, addr, e)) == e;
9UNSAFE_ENDD ~ o D
参考资料
- cas wikihttps://zh.wikipedw V ; . R I } 6ia.org/wiki/%E6%AF%94%E8%BE%83%E5%B9%B6%E4%BA%A4%E6%8D%A2
- 说一说J5 I ava的Unsafe类hi n y - D g https:{ O L v = 3 _ )//www.cnblogs.com/L ( Y qpkufork/p/java_unsafe.html
- Java Magic. Part 4: sun.misc.Unsafehttp://mishadoff.com/blog/java-magic-part-4-# h _ / 4 y n n [sun-dot-misc-dot-unsafe/