Github架构师解读C/C++应用包管理的Why和How

预计阅读需要23分钟

来源：

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 ~ $种锁都有其优劣势。

深入浅出 CAS(Compare And Swap)

使用锁就需要 / ? 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 就可以做到。

深入浅出 CAS(Compare And Swap)

但是像上面的操作在多线程下会让 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 #用就可以了。

不论是[ ^ & A @ ~ , @ y锁还是无锁都有其优劣势，后面我们也会通过例子说明 CAS 的问题。

什么是 CAS

前面提了无锁的 CAS，那到底 CAS 是个啥呢？我已经迫不及待了，我们A w v ~ F }来看看维基百科的解释

比较并交换(compare and swap, CAS)，是原子操作的一种，可用于在多线程编程中实现不被打断的数据交换操作，从而避免多线程同) a f S # /时改写某一数据时由于执行顺序不确定性以及中断的不可预知性产生的数据不一致问题。该操作通过将内存中的值与指定数据进行比较，当数值一样时将内存中的数据替换为新的值。

CAS 给我们提供了一种思路，通过 比较 和 替换 来完成原子性，来看一段代码：

1 int cas(lW t h + gong *addr, long old, long new) {
2 } k E r =;   9 D ; + | k;/* 原子执行&nbsn } * , w V np;*/
3q L M | L t Y I  W d Q ` _ C 3 Q;  , g h 9 k W y;if(*addr != old^ u C a D  1 = A)
4        returnR T x | + {&n% A Rbsp;0;
5    *addr = new;
6    return 1;
7 }

这是一段 c 语言代码，可以看到有 3 个参数，分8 1 q m / ; : R S别是：

  • *addi : g P %r: 进行比较g ` I } y ( %的值
  • old: 内存当前值
  • new: 准备修改的新值，写入到内存

只要我们当前传入的进行比较的值和内存里的值相等，就将新值修改成功，否则返回 0 告诉比较失败了。学过数据库的同学都知道悲观锁和乐观锁，乐观锁总是认R m 3 ] [ L为数据不会被修改。基于这种假设 CAS 的操作也认为内存里的值和当前值是相等的，所以操作总是能成功，我们可以不需要加锁就实现多线程下的原子性操作。

在多线程情况下使用 CAS 同时更新同h d Z 2一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被阻塞挂起，而是告诉它这次修改失败了，你可以重新尝试，于是可以写这样的代码。

1while (!cas(&addr, old, newValue{ 9 Y n W k p)) {
2
3}
4// success
5printf(\"new value = %C m u I ( tld\", addr);

不过这样的代码相信你可能看出其中的U 1 m / T蹊跷7 k H J ; ,了，这~ A F 5 & N * ! 8个我们后面来分析，下面来看看 Java 里是怎么用 CAS 的。

Java 里的 CAS

还是前面的问题，如果让t Q Y . f K你用 Java 的 API 来实现你可能会W 0 ^想到两种方式，一种是加锁（可能是 synchronized 或者其他种类的锁），另一种是使用 atomic 类，如 AtomicInteger，这一系列a = ;类是在 JDK1.5 的时候出现的，在我们常用的 java.util.concurrent.atomic 包下，我们来看个例子：

1 . ; X ExecutorServC H @ . K SiR # 1 & : * ! fce executorSe] t Frvice = Executors.newCacheh H @dThreadPool();
2 AtomicInteger   atomi0 [ C ] 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 [ +bsp;      g 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[ 0 X M O , P xsp;   }
43
44}

这% i Z . v ` d里我只帖出了我们前面例子相关的代码，其他都是类似的，可以看到. 5 : incrementAndGet 调用了 unsafe.getAndAddInQ J 2 h W b ] 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 @ [ L %对象（其实就是 AtomicInt` q E c -eger 实例）
  • var2: 当前要操作的变量偏移量（可以理解为 CAS 中的内存当前值）
  • va_ { o U k G . 6r4: 期望内存中的值
  • var5: 要修改的新值

所以 this.compareAndSwapInt(var1, vw # O 7 b 0 $ar2, var5, var5 + var4) 的意思就是，比较一下 var2 和内存当前值 var5 是否相等，如果相等那我就将内存值 var5 修改为 var5 + var4（var4 就是 1，也可以是其他数）。

这里我们还需要解释一下 偏移量 是个啥？你在前面的代码中可能看到这么一段：

 1/& U | y 9 o . / o/ setup to use&V + : Mnbsp;Unsafe.compareAndSwapInt for updates
 2private sta ~ ] 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 [ . $ C使用了 AtomicBoolean 这个类，当然用 AtomicInteger 也是可以的，因为我们只保存一个状态 boolean 占用比较小就用它了。这个锁的实现比较简$ { J l t i %单s O ?，缺点非常明显，由于U u _ whileh 4 4 5 e @ 循环导致的自M _ g I f M y i旋会让其他线程都在占用 CPU，但是也可以使用，关于锁的优化版本实现我会在后续的文章中进行改进和说明，正因为这些问题我们也会在后续研究 AQSL y F m 这把利器的优点。

CAS 源码

看了上面的这些代码和解释相信你对 CAS 已经理解了，下面我们要说的原理是前面的 native 方法中的 C++ 代码写了什么，在 openjdk 的 /hotspot/src/share/vm/prims 目录中有一个 Unsafe.cpp 文件中有这样一段代码：

注意：这里以 hotspot 实现为例

1UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject o 5 . X m R :obj, jlong offsh } ( a $ , ]etx [ 3, jint e, jint&nbh B k V b  Q 8 Dsp;x))
2  UnsafeWrapper(\"U[ Q Ensafe_CompareAndSwapInt\")~ Y  w V M [ 0 m;
3  oop p = JNIHandles::resolve(obj);
4  // 通过偏移量获取对象变量地址r z N
5  jint* addr = (jint *) index_oop_from_field_oD e : L Mffset_long(p, offset);
6 &nbs, b r ] & _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/
本文系本站编辑转载，文章版权归原作者所有，内容为作者个人观点，转载目的在于传递更多信息，并不代表本站赞同其观点和对其真实性负责。如涉及作品内容、版权和其它问题，请与本站联系，本站将在第一时间删除内容！
上一篇

自动驾驶汽车初创公司“Phantom AI”获2200万美元融资

下一篇

Conflux DEX 双子协议：链上结算 & 链下撮合

评论已经被关闭。

插入图片
返回顶部