1.概述

转载： 添加链接描述

2.什么是原子操作？

atomic 翻译成中文是原子的意思。在化学上，我们知道原子是构成一般物质的最小单位，在化学反应中是不可分割的。在我们这里 atomic 是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰，所以，所谓原子类说简单点就是具有原子操作特征的类，原子操作类提供了一些修改数据的方法，这些方法都是原子操作的，在多线程情况下可以确保被修改数据的正确性。

JUC中对原子操作提供了强大的支持，这些类位于java.util.concurrent.atomic包中，如下图：

3.JUC中原子类思维导图

4.基本类型原子类

使用原子的方式更新基本类型

AtomicInteger：int类型原子类AtomicLong：long类型原子类AtomicBoolean ：boolean类型原子类

上面三个类提供的方法几乎相同，这里以 AtomicInteger 为例子来介绍。

4.1 AtomicInteger 类常用方法

public final int get() //获取当前的值
public final int getAndSet(int newValue)//获取当前的值，并设置新的值
public final int getAndIncrement()//获取当前的值，并自增
public final int getAndDecrement() //获取当前的值，并自减
public final int getAndAdd(int delta) //获取当前的值，并加上预期的值
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）
public final void lazySet(int newValue)//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

4.2 部分源码

private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;static {try {valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));} catch (Exception ex) { throw new Error(ex); }
}private volatile int value;

2个关键字段说明：

value：使用volatile修饰，可以确保value在多线程中的可见性。
valueOffset：value属性在AtomicInteger中的偏移量，通过这个偏移量可以快速定位到value字段，这个是实现AtomicInteger的关键。

4.3 getAndIncrement源码：

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

内部调用的是Unsafe类中的getAndAddInt方法，我们看一下getAndAddInt源码：

public final int getAndAddInt(Object var1, long var2, int var4) {int var5;do {var5 = this.getIntVolatile(var1, var2);} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));return var5;
}

说明：

1. this.getIntVolatile：可以确保从主内存中获取变量最新的值。
2. compareAndSwapInt：CAS操作，CAS的原理是拿期望的值和原本的值作比较，如果相同则更新成新的值，可以确保在多线程情况下只有一个线程会操作成功，不成功的返回false。

上面有个do-while循环，compareAndSwapInt返回false之后，会再次从主内存中获取变量的值，继续做CAS操作，直到成功为止。

getAndAddInt操作相当于线程安全的count++操作，如同：

synchronize(lock){count++;
}

count++操作实际上是被拆分为3步骤执行：

1. 获取count的值，记做A：A=count
2. 将A的值+1，得到B：B = A+1
3. 让B赋值给count：count = B
   多线程情况下会出现线程安全的问题，导致数据不准确。

synchronize的方式会导致占时无法获取锁的线程处于阻塞状态，性能比较低。CAS的性能比synchronize要快很多。

4.4 示例

使用AtomicInteger实现网站访问量计数器功能，模拟100人同时访问网站，每个人访问10次，代码如下：

package com.itsoku.chat23;import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;/*** 跟着阿里p7学并发，微信公众号：javacode2018*/
public class Demo1 {//访问次数static AtomicInteger count = new AtomicInteger();//模拟访问一次public static void request() throws InterruptedException {//模拟耗时5毫秒TimeUnit.MILLISECONDS.sleep(5);//对count原子+1count.incrementAndGet();}public static void main(String[] args) throws InterruptedException {long starTime = System.currentTimeMillis();int threadSize = 100;CountDownLatch countDownLatch = new CountDownLatch(threadSize);for (int i = 0; i < threadSize; i++) {Thread thread = new Thread(() -> {try {for (int j = 0; j < 10; j++) {request();}} catch (InterruptedException e) {e.printStackTrace();} finally {countDownLatch.countDown();}});thread.start();}countDownLatch.await();long endTime = System.currentTimeMillis();System.out.println(Thread.currentThread().getName() + "，耗时：" + (endTime - starTime) + ",count=" + count);}
}

输出：

main，耗时：158,count=1000

通过输出中可以看出incrementAndGet在多线程情况下能确保数据的正确性。

5.数组类型原子类介绍

使用原子的方式更新数组里的某个元素，可以确保修改数组中数据的线程安全性。

AtomicIntegerArray：整形数组原子操作类AtomicLongArray：长整形数组原子操作类AtomicReferenceArray ：引用类型数组原子操作类

上面三个类提供的方法几乎相同，所以我们这里以 AtomicIntegerArray 为例子来介绍。

5.1 AtomicIntegerArray 类常用方法

public final int get(int i) //获取 index=i 位置元素的值
public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue
public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增
public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减
public final int getAndAdd(int delta) //获取 index=i 位置元素的值，并加上预期的值
boolean compareAndSet(int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）
public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

示例

统计网站页面访问量，假设网站有10个页面，现在模拟100个人并行访问每个页面10次，然后将每个页面访问量输出，应该每个页面都是1000次，代码如下：

package com.itsoku.chat23;import java.util.Arrays;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerArray;/*** 跟着阿里p7学并发，微信公众号：javacode2018*/
public class Demo2 {static AtomicIntegerArray pageRequest = new AtomicIntegerArray(new int[10]);/*** 模拟访问一次** @param page 访问第几个页面* @throws InterruptedException*/public static void request(int page) throws InterruptedException {//模拟耗时5毫秒TimeUnit.MILLISECONDS.sleep(5);//pageCountIndex为pageCount数组的下标，表示页面对应数组中的位置int pageCountIndex = page - 1;pageRequest.incrementAndGet(pageCountIndex);}public static void main(String[] args) throws InterruptedException {long starTime = System.currentTimeMillis();int threadSize = 100;CountDownLatch countDownLatch = new CountDownLatch(threadSize);for (int i = 0; i < threadSize; i++) {Thread thread = new Thread(() -> {try {for (int page = 1; page <= 10; page++) {for (int j = 0; j < 10; j++) {request(page);}}} catch (InterruptedException e) {e.printStackTrace();} finally {countDownLatch.countDown();}});thread.start();}countDownLatch.await();long endTime = System.currentTimeMillis();System.out.println(Thread.currentThread().getName() + "，耗时：" + (endTime - starTime));for (int pageIndex = 0; pageIndex < 10; pageIndex++) {System.out.println("第" + (pageIndex + 1) + "个页面访问次数为" + pageRequest.get(pageIndex));}}
}

输出：

main，耗时：635
第1个页面访问次数为1000
第2个页面访问次数为1000
第3个页面访问次数为1000
第4个页面访问次数为1000
第5个页面访问次数为1000
第6个页面访问次数为1000
第7个页面访问次数为1000
第8个页面访问次数为1000
第9个页面访问次数为1000
第10个页面访问次数为1000

说明：

代码中将10个面的访问量放在了一个int类型的数组中，数组大小为10，然后通过AtomicIntegerArray来操作数组中的每个元素，可以确保操作数据的原子性，每次访问会调用incrementAndGet，此方法需要传入数组的下标，然后对指定的元素做原子+1操作。输出结果都是1000，可以看出对于数组中元素的并发修改是线程安全的。如果线程不安全，则部分数据可能会小于1000。

其他的一些方法可以自行操作一下，都非常简单。

6.引用类型原子类介绍

基本类型原子类只能更新一个变量，如果需要原子更新多个变量，需要使用 引用类型原子类。

AtomicReference：引用类型原子类AtomicStampedRerence：原子更新引用类型里的字段原子类AtomicMarkableReference ：原子更新带有标记位的引用类型

AtomicReference 和 AtomicInteger 非常类似，不同之处在于 AtomicInteger是对整数的封装，而AtomicReference则是对应普通的对象引用，它可以确保你在修改对象引用时的线程安全性。在介绍AtomicReference的同时，我们先来了解一个有关原子操作逻辑上的不足。

6.1 ABA问题

之前我们说过，线程判断被修改对象是否可以正确写入的条件是对象的当前值和期望值是否一致。这个逻辑从一般意义上来说是正确的，但是可能出现一个小小的例外，就是当你获得当前数据后，在准备修改为新值钱，对象的值被其他线程连续修改了两次，而经过这2次修改后，对象的值又恢复为旧值，这样，当前线程就无法正确判断这个对象究竟是否被修改过，这就是所谓的ABA问题，可能会引发一些问题。

举个例子

有一家蛋糕店，为了挽留客户，决定为贵宾卡客户一次性赠送20元，刺激客户充值和消费，但条件是，每一位客户只能被赠送一次，现在我们用AtomicReference来实现这个功能，代码如下：

package com.itsoku.chat22;import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;/*** 跟着阿里p7学并发，微信公众号：javacode2018*/
public class Demo3 {//账户原始余额static int accountMoney = 19;//用于对账户余额做原子操作static AtomicReference<Integer> money = new AtomicReference<>(accountMoney);/*** 模拟2个线程同时更新后台数据库，为用户充值*/static void recharge() {for (int i = 0; i < 2; i++) {new Thread(() -> {for (int j = 0; j < 5; j++) {Integer m = money.get();if (m == accountMoney) {if (money.compareAndSet(m, m + 20)) {System.out.println("当前余额：" + m + "，小于20，充值20元成功，余额：" + money.get() + "元");}}//休眠100mstry {TimeUnit.MILLISECONDS.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}).start();}}/*** 模拟用户消费*/static void consume() throws InterruptedException {for (int i = 0; i < 5; i++) {Integer m = money.get();if (m > 20) {if (money.compareAndSet(m, m - 20)) {System.out.println("当前余额：" + m + "，大于10，成功消费10元，余额：" + money.get() + "元");}}//休眠50msTimeUnit.MILLISECONDS.sleep(50);}}public static void main(String[] args) throws InterruptedException {recharge();consume();}}

输出：

当前余额：19，小于20，充值20元成功，余额：39元
当前余额：39，大于10，成功消费10元，余额：19元
当前余额：19，小于20，充值20元成功，余额：39元
当前余额：39，大于10，成功消费10元，余额：19元
当前余额：19，小于20，充值20元成功，余额：39元
当前余额：39，大于10，成功消费10元，余额：19元
当前余额：19，小于20，充值20元成功，余额：39元

从输出中可以看到，这个账户被先后反复多次充值。其原因是账户余额被反复修改，修改后的值和原有的数值19一样，使得CAS操作无法正确判断当前数据是否被修改过（是否被加过20）。虽然这种情况出现的概率不大，但是依然是有可能出现的，因此，当业务上确实可能出现这种情况时，我们必须多加防范。JDK也为我们考虑到了这种情况，使用AtomicStampedReference可以很好地解决这个问题。

6.2 使用AtomicStampedRerence解决ABA的问题

AtomicReference无法解决上述问题的根本原因是，对象在被修改过程中丢失了状态信息，比如充值20元的时候，需要同时标记一个状态，用来标注用户被充值过。因此我们只要能够记录对象在修改过程中的状态值，就可以很好地解决对象被反复修改导致线程无法正确判断对象状态的问题。

AtomicStampedRerence正是这么做的，他内部不仅维护了对象的值，还维护了一个时间戳（我们这里把他称为时间戳，实际上它可以使用任何一个整形来表示状态值），当AtomicStampedRerence对应的数值被修改时，除了更新数据本身外，还必须要更新时间戳。当AtomicStampedRerence设置对象值时，对象值及时间戳都必须满足期望值，写入才会成功。因此，即使对象值被反复读写，写回原值，只要时间戳发生变量，就能防止不恰当的写入。

AtomicStampedRerence的几个Api在AtomicReference的基础上新增了有关时间戳的信息。

//比较设置，参数依次为：期望值、写入新值、期望时间戳、新时间戳
public boolean compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp);
//获得当前对象引用
public V getReference();
//获得当前时间戳
public int getStamp();
//设置当前对象引用和时间戳
public void set(V newReference, int newStamp);

现在我们使用AtomicStampedRerence来修改一下上面充值的问题，代码如下：

package com.itsoku.chat22;import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;/*** 跟着阿里p7学并发，微信公众号：javacode2018*/
public class Demo4 {//账户原始余额static int accountMoney = 19;//用于对账户余额做原子操作static AtomicStampedReference<Integer> money = new AtomicStampedReference<>(accountMoney, 0);/*** 模拟2个线程同时更新后台数据库，为用户充值*/static void recharge() {for (int i = 0; i < 2; i++) {int stamp = money.getStamp();new Thread(() -> {for (int j = 0; j < 50; j++) {Integer m = money.getReference();if (m == accountMoney) {if (money.compareAndSet(m, m + 20, stamp, stamp + 1)) {System.out.println("当前时间戳：" + money.getStamp() + ",当前余额：" + m + "，小于20，充值20元成功，余额：" + money.getReference() + "元");}}//休眠100mstry {TimeUnit.MILLISECONDS.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}}}).start();}}/*** 模拟用户消费*/static void consume() throws InterruptedException {for (int i = 0; i < 50; i++) {Integer m = money.getReference();int stamp = money.getStamp();if (m > 20) {if (money.compareAndSet(m, m - 20, stamp, stamp + 1)) {System.out.println("当前时间戳：" + money.getStamp() + ",当前余额：" + m + "，大于10，成功消费10元，余额：" + money.getReference() + "元");}}//休眠50msTimeUnit.MILLISECONDS.sleep(50);}}public static void main(String[] args) throws InterruptedException {recharge();consume();}}

输出：

当前时间戳：1,当前余额：19，小于20，充值20元成功，余额：39元
当前时间戳：2,当前余额：39，大于10，成功消费10元，余额：19元

结果正常了。

关于这个时间戳的，在数据库修改数据中也有类似的用法，比如2个编辑同时编辑一篇文章，同时提交，只允许一个用户提交成功，提示另外一个用户：博客已被其他人修改，如何实现呢？

博客表：t_blog（id,content,stamp)，stamp默认值为0，每次更新+1

A、B 二个编辑同时对一篇文章进行编辑，stamp都为0，当点击提交的时候，将stamp和id作为条件更新博客内容，执行的sql如下：

update t_blog set content = 更新的内容,stamp = stamp+1
where id = 博客id and stamp = 0;

这条update会返回影响的行数，只有一个会返回1，表示更新成功，另外一个提交者返回0，表示需要修改的数据已经不满足条件了，被其他用户给修改了。这种修改数据的方式也叫乐观锁。

7.对象的属性修改原子类介绍

如果需要原子更新某个类里的某个字段时，需要用到对象的属性修改原子类。

AtomicIntegerFieldUpdater：原子更新整形字段的值AtomicLongFieldUpdater：原子更新长整形字段的值AtomicReferenceFieldUpdater ：原子更新应用类型字段的值

要想原子地更新对象的属性需要两步：

1. 第一步，因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须使用静态方法 newUpdater()创建一个更新器，并且需要设置想要更新的类和属性。

2. 第二步，更新的对象属性必须使用 public volatile 修饰符。

上面三个类提供的方法几乎相同，所以我们这里以AtomicReferenceFieldUpdater为例子来介绍。

调用AtomicReferenceFieldUpdater静态方法newUpdater创建AtomicReferenceFieldUpdater对象

public static <U, W> AtomicReferenceFieldUpdater<U, W> newUpdater(Class<U> tclass, Class<W> vclass, String fieldName)

说明:

三个参数

tclass：需要操作的字段所在的类
vclass：操作字段的类型
fieldName：字段名称

示例

多线程并发调用一个类的初始化方法，如果未被初始化过，将执行初始化工作，要求只能初始化一次

代码如下：

package com.itsoku.chat22;import com.sun.org.apache.xpath.internal.operations.Bool;import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;/*** 跟着阿里p7学并发，微信公众号：javacode2018*/
public class Demo5 {static Demo5 demo5 = new Demo5();//isInit用来标注是否被初始化过volatile Boolean isInit = Boolean.FALSE;AtomicReferenceFieldUpdater<Demo5, Boolean> updater = AtomicReferenceFieldUpdater.newUpdater(Demo5.class, Boolean.class, "isInit");/*** 模拟初始化工作** @throws InterruptedException*/public void init() throws InterruptedException {//isInit为false的时候，才进行初始化，并将isInit采用原子操作置为trueif (updater.compareAndSet(demo5, Boolean.FALSE, Boolean.TRUE)) {System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + "，开始初始化!");//模拟休眠3秒TimeUnit.SECONDS.sleep(3);System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + "，初始化完毕!");} else {System.out.println(System.currentTimeMillis() + "," + Thread.currentThread().getName() + "，有其他线程已经执行了初始化!");}}public static void main(String[] args) {for (int i = 0; i < 5; i++) {new Thread(() -> {try {demo5.init();} catch (InterruptedException e) {e.printStackTrace();}}).start();}}
}

输出：

1565159962098,Thread-0，开始初始化!
1565159962098,Thread-3，有其他线程已经执行了初始化!
1565159962098,Thread-4，有其他线程已经执行了初始化!
1565159962098,Thread-2，有其他线程已经执行了初始化!
1565159962098,Thread-1，有其他线程已经执行了初始化!
1565159965100,Thread-0，初始化完毕!

说明：

1. isInit属性必须要volatille修饰，可以确保变量的可见性

2. 可以看出多线程同时执行init()方法，只有一个线程执行了初始化的操作，其他线程跳过了。多个线程同时到达updater.compareAndSet，只有一个会成功

【高并发】JUC中原子类介绍相关推荐

1. Java高并发 - JUC

   1.基础概念 进程.线程.管程 进程 系统中一个运行的程序就是一个进程,每个进程都有自己的内存空间和系统资源 进程是操作系统分配资源的基本单位 线程 也叫做轻量级进程,一个进程中有多个线程,这些线程共 ...

2. solr 高并发_Solr搜索引擎 — SolrCloud介绍和环境准备

   搞定了一切的一切之后下一步就是正式使用了,但是之前介绍的都是在单台服务器上进行的部署,如果在生产环境出现了单台故障怎么办呢?提供稳定性和性能的最直观的方式就是集群,solr官方提供了cloud的集群方 ...

3. 【Java】高并发-JUC:JUC中的Condition对象

   1.Condition使用简介 从整体上来看Object的wait和notify/notify是与对象监视器配合完成线程间的等待/通知机制,而Condition与Lock配合完成等待通知机制,前者是j ...

4. (大厂必备)厂长熬夜爆肝万字之多线程高并发JUC编程(一)⭐学妹已收藏

5. 【1024面试必备】厂长爆肝万字之多线程高并发JUC编程⭐建议收藏

6. (大厂必备)厂长熬夜爆肝万字之多线程高并发JUC编程(二)⭐学妹已收藏

7. 【高并发】- 指标介绍

   什么是高并发 高并发系统有哪些关键指标 高并发系统介绍 本文主要讲解高并发系统的概念,在实际开发过程中为什么要使用高并发系统,相比于传统系统,能带来怎样的改变. 1.1 高并发介绍 高并发(Hign ...

8. shell 获取命令执行结果_java高并发系列 第31天：获取线程执行结果，这6种方法你都知道？...

   这是java高并发系列第31篇. 环境:jdk1.8. java高并发系列已经学了不少东西了,本篇文章,我们用前面学的知识来实现一个需求: 在一个线程中需要获取其他线程的执行结果,能想到几种方式?各有 ...

9. 高并发中计数器的实现方式有哪些？

   1.概述 转载:添加链接描述 4种方式实现计数器功能,对比其性能 介绍LongAdder 介绍LongAccumulator 需求:一个jvm中实现一个计数器功能,需保证多线程情况下数据正确性. 我们 ...

最新文章

1. 组件生命周期管理和通信方案
2. 视频：easyhadoop聚会hive和phpHiveAdmin部分
3. 下述有关计算机网络的描述错误的是6,下述有关计算机总线的描述错误的是（ ） 。...
4. 读取数据库名及表与表中的字段
5. idea java8_太赞了，Intellij IDEA 竟然把 Java8 的数据流问题这么完美的解决掉了！...
6. 小程序、vue 新闻上下轮播
7. cmd中python -V版本显示不出来
8. oracle级联赋权,Oracle 级联with admin option 和 with grant option
9. java 多线程4: java线程的优先级
10. Java中如何将以byte数组给出的数据转换为double数组形式
11. 复习：关于类的继承和构造函数
12. 吴恩达深度学习笔记 course2 week2 优化算法
13. 华为linux服务器系统安装,linux服务器系统安装
14. 《社会调查数据管理——基于Stata 14管理CGSS数据》一3.4　Stata的一些术语及使用通则...
15. 网际风全推数据接口_网际风千钧版 飞狐配套全推接口最新版（2013年5月10更新）...
16. 【强化学习】强化学习介绍
17. 一天接收了131份前端面试简历......（面试总结）
18. linux终端界面美化,Ubuntu 18.04系统美化记录：Grub2\主题\登录界面\终端美化
19. 取消IPV4自动配置
20. 使用IDEA完成支付宝开放平台的Demo测试

热门文章

1. 教育部成立校外教育培训监管司 K12迎最强监管 教育中概股再跳水
2. 烟台市与拼多多达成战略合作 启动烟台优品线上云购节活动
3. 声网：疫情期间日均通话分钟数较日常增长近一倍 达15.6亿分钟
4. 刘作虎：一加新品将全系支持 5G
5. 快手春晚10亿元红包玩法来了：最高得2020元现金
6. 外媒：Airbnb为2020年直接上市作准备
7. 工信部回应“网传4G降速”：从未要求运营商降速
8. 华为Mate 30 Pro保护壳生产线谍照曝光：长方形摄像头模组实锤？
9. 运行了9年的QQ邮箱经典功能 终于还是迎来了终止服务
10. 汽车金融平台百金贷宣布良性退出网贷业务