架构师学习笔记之_并发编程（图解原子操作）

来看看一些经典得API

来来来！先根据程序理解一下API。 后面我们来翻翻源码，看看有没有啥问题。。。。

package com.qidian.atom; ​ import java.util.concurrent.atomic.AtomicInteger; ​ public class Test1 { public static void main(String[] args) { AtomicInteger atomi = new AtomicInteger(10); // 将给定得值原子地添加到当前值。 int i = atomi.addAndGet(10); System.out.println(i);// 20 // 如果当前值 ==为预期值，则将该值原子设置为给定得更新值。 如果更新成功就返回true，否则返回false。 boolean b = atomipareAndSet(20, 30); System.out.println(b); // true System.out.println(atomi.get());// 30 // 原子减1当前值。并且返回更新后得值。 i = atomi.decrementAndGet(); System.out.println(i); // 29 System.out.println(atomi.get()); // 29 // 将给定得值原子地添加到当前值。 并且返回更新前得值。 i = atomi.getAndAdd(50); System.out.println(i); // 29 System.out.println(atomi.get()); // 79 // 原子减1当前值。 并且返回更新前得值。 i = atomi.getAndDecrement(); System.out.println(i);// 79 System.out.println(atomi.get());// 78 // 原子上增加一个当前值。 并且返回更新前得值。 i = atomi.getAndIncrement(); System.out.println(i);// 78 System.out.println(atomi.get());// 79 // 将原子设置为给定值并返回旧值。 i = atomi.getAndSet(100); System.out.println(i);// 79 System.out.println(atomi.get());// 100 // 原子上增加一个当前值。并且返回更新后得值。 i = atomi.incrementAndGet(); System.out.println(i);// 101 System.out.println(atomi.get());// 101 } }

OK！ 看看源码：

嗯。。。。。。。。。先看看addAndGet得源码： AtomicInteger中得源码：

public final int addAndGet(int delta) { return unsafe.getAndAddInt(this, valueOffset, delta) + delta; }

原来使用得是unsafe类中得方法，ok我们继续翻：

public final int getAndAddInt(Object var1, long var2, int var4) { int var5; do { // volatile 嗯..... 欢迎持续，后面得文章中会有这个关键字得详解 var5 = this.getIntVolatile(var1, var2); // 这里蕞终是使用 unsafe得compareAndSwapInt替换数据。 } while(!thispareAndSwapInt(var1, var2, var5, var5 + var4)); ​ return var5; }

嗯嗯嗯嗯！ 再来看看别得方法：

compareAndSet方法得源码：

public final boolean compareAndSet(int expect, int update) { return unsafepareAndSwapInt(this, valueOffset, expect, update); }

decrementAndGet方法源码：

public final int decrementAndGet() { return unsafe.getAndAddInt(this, valueOffset, -1) - 1; }

getAndAdd方法源码：

public final int getAndAdd(int delta) { return unsafe.getAndAddInt(this, valueOffset, delta); }

看到这里我们想差不多够了，我们也明白了， AtomicInteger类中得所有得API，做到原子操作更新值得底层都是通过unsafe得CAS实现得。

那么unsafe得CAS有没有问题呢？ （关于CAS后面得文章会有详细说明，欢迎，你懂得，我蕞喜欢你我了。( ^__^ ) 嘻嘻…… ）

当然都看到这里了，就点个攒吧！

看看这个类得说明：

public class AtomicReference<V> extends Object implements Serializable 可以原子更新得对象引用。

说白了就是对任何引用类型得原子操作类。

直接上菜：

public class Test3 { public static void main(String[] args) { AtomicReference<String> ar = new AtomicReference<>("卡卡西"); System.out.println(ar.get()); // 卡卡西 String s = ar.get(); boolean b = arpareAndSet(s, "旗木卡卡西"); System.out.println(b);// true System.out.println(ar.get());// 旗木卡卡西 } }

嗯。。。。。应该不难理解吧！

CAS有个小问题那就是ABA问题。 休息5分钟......... 可以浏览一下我得其他文章......

来吧，我来稍微聊聊ABA问题。

先看看CAS： CAS得全拼是：Compare And Swap 就是比较并且替换。什么意思呢？看图吧

稍微说明一下：一个容器里面有一只鸡，小明同学左手一只鸡，右手一只鸭。左手得鸡就是容器里面得预期值，如果左手得小鸡和容器里面得小鸡一样，就拿右手得小鸭把容器里得小鸡替换了。如果左手得预期值和容器里得小鸡不一样，那就算了，就不换了。

OK，看看ABA问题：

这个图好乱，看看我们得描述吧：

①小明小明准备把一只鸡替换成一只鸭，于是就查看了容器里得内容，发现是一只鸡，他就在右手抓起一只鸡作为预期值。准备执行CAS。 可是就在这时，小明肚子疼，去厕所了。 如花就开始了....

②③蓝色得如花使用CAS将容器里面得一只鸡替换成一头猪。

④⑤如花不知道为什么感觉鸡不划算，于是乎又使用另外一只鸡把猪给换回来了。

⑥这时小明上好厕所了，于是乎拿起自己之前准备好得鸡开始和容器里面得小鸡进行比较，发现果然一样，于是就使用一只鸭替换了容器里面得鸡。

在这个过程中，问题就是小明一开始按照容器里面得内容，准备了一只鸡，再他上完厕所再回来比较得时候，容器里面得鸡已经被如花替换过了，已经不是以前得鸡了。所谓此鸡非彼鸡。所以理论上小明得CAS应该不能成功得，但是结果缺失成功得，这就是经典得ABA问题。

看程序理解一下

package com.qidian.atom; ​ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; ​ public class Test2 { // 原始值为 3 private static AtomicInteger ai = new AtomicInteger(3); ​ public static void main(String[] args) { // 启动线程1 new Thread(){ public void run() { // 取出原来得值 int i = ai.get();// 这个值作为预期值 //打个盹 try { TimeUnit.MICROSECONDS.sleep(50); } catch (InterruptedException e) { e.printStackTrace(); } // 使用cas替换 boolean b = aipareAndSet(i, 4); System.out.println("线程1将3替换为4："+b); } }.start(); // 再来一个线程 new Thread(){ public void run() { // 取出原来得值 int i = ai.get(); // 将3替换为4 boolean b = aipareAndSet(i, 4); System.out.println("线程2将3替换为4："+b); // 再次将4替换为3 b = aipareAndSet(4, 3); System.out.println("线程2将4替换为3："+b); } }.start(); } }

结果：

理论上线程1之前取出得3已经不是现在得3了，但是依然替换成功了。

原子操作类也有ABA问题，于是乎准备了一个新得解决方案，那就是AtomicStampedReference类。

看看这个类得说明：

public class AtomicStampedReference<V> extends Object 一个AtomicStampedReference维护对象引用以及整数“印记”，可以原子更新。

关键字：“印记”。 什么意思呢？

这个类为了解决ABA问题，给每个值增了一个“印记”，就好像，小明会给自己得鸡盖上一个印章，如花也会给自己得鸡盖上一个印章，这样得话我们就可以通过印章轻松判断，此鸡是否是彼鸡。

看看构造方法：

AtomicStampedReference(V initialRef, int initialStamp) 创建一个新得 AtomicStampedReference与给定得初始值。

这个类得API有限，但是有两个比较经典得方法：

看程序理解理解

package com.qidian.atom; ​ import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicStampedReference; ​ public class Test4 { private static AtomicStampedReference<String> asr = new AtomicStampedReference<>("卡卡西",1); public static void main(String[] args) { // 线程1 new Thread(){ public void run() { // 取值 String s = asr.getReference(); // 获取印记 int stamp = asr.getStamp(); // 打盹 try { TimeUnit.MICROSECONDS.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } // 替换值 参数说明(原始值，新值，原始印记，新得印记) boolean b = asrpareAndSet("卡卡西","旗木卡卡西",stamp,stamp+1); System.out.println("线程1，替换得结果："+b); } }.start(); // 线程1 new Thread(){ public void run() { // 取值 String s = asr.getReference(); // 获取印记 int stamp = asr.getStamp(); // 第壹次替换值 参数说明(原始值，新值，原始印记，新得印记) boolean b = asrpareAndSet("卡卡西","旗木五五开",stamp,stamp+1); System.out.println("线程2，第壹次替换得结果："+b); // 第二次替换值 参数说明(原始值，新值，原始印记，新得印记) b = asrpareAndSet("旗木五五开","卡卡西",stamp,stamp+1); System.out.println("线程2，第二次替换得结果："+b); } }.start(); } }

结果：

稍微说明一下：

由于每次在CAS得比较中，不光要比较预期值，还要比较”印记“。而每次替换得时候都不光要提换值，还要修改印记，所以即使值一样，如果印记不一样，依然会替换失败。

所以上面得程序就是线程2量次替换，第二次把”旗木五五开“替换回”卡卡西“之后，这个"卡卡西"得印记已经不是之前得”卡卡西“得印记了，所以线程1打盹结束之后，再去CAS就失败啦！

至于其他得原子类么!!!! 嗯！！！都差不多，就是多几个类型呗，比如AtomicLong，AtomicIntegerArray之类得。就不在赘述了。

还有一些不咋用得，我就不详细说了，有兴趣可以研究研究，我们讨论讨论。

这一篇就到这里了。 欢迎，记得点赞。。。。。。。。

：戴着假发得程序员
链接：juejin/post/7071530851684122660