Java并发之原子变量及CAS算法原理-合

Java并发之原子变量及CAS算法

概述

本文主要讲在Java并发编程的时候，如果保证变量的原子性，在JDK提供的类中式怎么保证变量原子性的呢？。对应Java中的包是：java.util.concurrent.atomic包下

本文是《凯哥分享Java并发编程之J.U.C包讲解》系列教程中的一篇。如果想系统学习，建议从第一篇开始看。

原子变量案例

在Java中有一种写法：int i = 10; i++ 这种写法。

我们先来看看：

输入的是0还是1呢 ？

I++输出0的原因分析

答案是：0。为什么呢？凯哥把编译后的class文件反编译，咱们看:

说明：i的操作是i++;y的操作是++y.

从反编译后的代码，我们可以看到i++在JVM中的操作，总共分三步：

第一步：声明变量var10000 ,然后将i赋值给var10000，此时var10000的值是0;

第二步：声明变量var3 然后把i+1 赋值给var3,此时，var3的值等于1了;

第三步：将变量var10000的值又赋值给了i,此时因为var10000的值是0，所以i的值也是0

所以在sysout(i)的时候，就输出了0.

我们分析上面1，2，3步骤，可以发现。其实i++执行的是：读取-修改-重写 三个操作。

既然读写操作，就会涉及到变量原子性。测试在多线程下变量原子性

测试多线程下的变量原子性

那么，如果我们把对i的操作放到多个线程中操作结果会是什么样的呢？

线程操作I的代码：

开启十个线程同时操作i的代码：

我们来看看运行结果：

从运行结果中，我们可以看到，线程Thread-5和线程Thread-8的值是一样的。

根据上面运行的场景，我们发现，变量i其实是十个线程中的共享变量。从运行的结果来看，多个线程操作后，结果出问题了。

不同线程在内存中运行模拟图：

线程1；线程2；以及主线程之间运行关系，可以详见凯哥上一篇文章：《Java并发之内存可见性问题怎么解决》。这篇文章详细讲解了怎么关系。

已经看过凯哥上一篇文章或者是知道volatile关键字的朋友可能要说，这不就是线程之间变量可见性问题嘛。使用volatile关键字修饰i就可以了。真的可以了吗？

我们修改程序，用volatile来修饰，看看运行结果：

使用volatile关键字是否能解决多线程情况下变量原子性呢？

用volatile来修饰变量：

private volatile int   shardData = 0;

运行结果：

我们发现，就算使用volatile关键字修饰了，依然存在多线程下变量原子性的问题。

怎么解决这种并发下变量原子性问题呢？

Java的atomic包

在jdk1.5以后，Java为我们提供了一个常用的原子变量。都在：java.util.concureent.atomic包下。我们来看看，都有哪些：

从JDK的API文档中(凯哥使用的是JDK1.8的API)我们可以看到常用的原子性变量。

怎么保证原子性呢？

那么，在atomic包下的这些类怎么保证原子性呢？

1：该包下的变量都是使用volatile关键字来修饰。

解决了多线程之间变量可见性。

Int类型的原子性对象AtomicInteger对象中：

用于对象的AtomicReference对象中：

都是使用volat关键字修饰的。

2：使用CAS算法

保持了变量的原子性

CAS简介

什么是CAS算法？

CAS:Compare-And-Swap即比较并交换的意思。

CAS包含了三个操作的数据：

主内存中的变量值:V

预估值(可以理解为原来旧的值):A

更新值(操作后，要更新的值)：B

CAS的特点：

当且仅当预估值A=内存值V的时候，才会将V的值更新为B。否则也不操作。

V==A;V=B;

使用CAS算法多线程操作的时候，有且仅有一个线程可以操作成功，其他线程都会操作失败。失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。

失败的线程采用自旋来进行尝试的。

我们以AtomicInteger对象中的getAndIncrement()方法为例来看看：

模拟后的源码：

CAS VS Synchroized比较

那么CAS的算法的效率为什么会比Synchronized的效率高呢？

Synchroized是阻塞算法的;而CAS是非阻塞的，采用的是乐观锁技术。

因为阻塞算法是CPU切换的，而CAS是CPU指令操作。CPU切换时间相对于CPU指令操作来说时间更长。所以使用CAS算法的线程比使用Synchroized的效率高。

CAS的优缺点

优点：一种线程同步的解决方案，使用CAS就可以不用加锁来实现线程的安全性。

缺点：

1：只能保证一个共享变量的原子操作；

2：循环时间长，开销很大；

3：会产生ABA问题。

缺点解决方案：

缺点一：

当对一个共享变量操作的时候，可以使用带有自旋(循环)的CAS方法来保证原子性操作，但是如果是多个变量共享的时候，可以封装到对象中或者是使用锁来保证原子性。

缺点二：

如果采用自旋的CAS方式来保证原子性，会一直进行尝试。如果时间太长的话，对CPU来说也会带来很大开销的。

缺点三：ABA问题

何为ABA问题？

如线程A修改共享变量值为A；线程B修改值为B。后来共享变量有被修改成了A，这种情况下CAS算法操作就会误认为共享变量A没有别修改过。这就是CAS算法的“漏洞”。

举个很简单的例子：

解决ABA问题

看到这里大家或许心里会想，我Kao,这不就是一个坑吗？JDK埋下的坑!既然有这个坑，那还敢用吗？？淡定，保持淡定点。你能想到的问题，JDK开发者也能想到。所以补救办法就是：

在atomic包中提供了一个：AtomicStampedReference类。

注意：是AtomicStampedReference。虽然和AtomicReference这个类有点像。但是不一样。

查看源码注释：

翻译：

简单理解，就是这个类添加了一个版本号。，每次操作都对版本号进行自增，那每次CAS不仅要比较value，还要比较stamp，当且仅当两者都相等，才能够进行更新。

具体怎么操作的呢？

在初始化的时候，就定义了pair对象。

在compareAndSet的时候，回对版本号进行比较。如下图：

讲明白了CAS原理之后，我们来修改i++的问题。使其成为保证原子性：

很简单只需要修改两行代码即可：

1：声明变量的时候使用AtomicInteger对象：

private AtomicInteger shardData = new AtomicInteger(0);

new AtomicInteger(0)其中的0可以不用写

2：修改i++的方法：

return shardData.getAndIncrement();

这样就可以了。

总结

Java中保证变量原子性使用的是current.atomic包下的对象来实现的。

如何保证原子性呢？

1：变量都是用volatile关键字修饰后，保证了内存的可见性；

2：使用CAS算法，保证了原子性。

Synchroized VS volatile VS CAS

在上一篇文章中我们知道了Volatile只能保证变量共享变量在内存中的可见性；不互斥；不能保证原子性；

在本篇中，我们知道了CAS是非阻塞的使用乐观锁技术来实现原子性。但是会产生其他问题，不过也可以解决。

Synchroized是阻塞性算法的实现。具有互斥性.