文章目录

线程安全性文章索引
脑图
概述
原子更新基本类型
- Demo
- AtomicBoolean 场景举例
原子更新数组
- Demo
原子更新引用类型
- Demo
原子更新字段类型
- 使用注意事项：
- Demo
原子类线程安全的原理
代码

线程安全性文章索引

并发编程-03线程安全性之原子性（Atomic包）及原理分析

并发编程-04线程安全性之原子性Atomic包的4种类型详解

并发编程-05线程安全性之原子性【锁之synchronized】

并发编程-06线程安全性之可见性 (synchronized + volatile)

并发编程-07线程安全性之有序性

脑图

概述

在实际应用中，当我们更新一个变量时，在并发环境下，如果多个线程同时去更新这个变量，更新后的值可能不是我们期望的值。

如果理解Java内存模型 JMM的原理的话，上面这个结论就很容易理解了。可参考下前面写的这篇文章
并发编程-02并发基础CPU多级缓存和Java内存模型JMM

举个例子：
【多线程场景】假设有个变量a在主内存中的初始值为1，线程A和线程B同时从主内存中获取到了a的值，线程A更新a+1，线程B也更新a+1，经过线程AB更新之后可能a不等于3，而是等于2。因为A和B线程在更新变量a的时候从主内存中拿到的a都是1，而不是等A更新完刷新到主内存后，线程B再从主内存中取a的值去更新a，所以这就是线程不安全的更新操作.

解决办法

使用锁 1. 使用synchronized关键字synchronized会保证同一时刻只有一个线程去更新变量. 2、Lock接口【篇幅原因先不讨论synchronized和lock，另开篇介绍】
使用JDK1.5开始提供的java.util.concurrent.atomic包，该包中的原子操作类提供了一种用法简单、性能高效、线程安全地更新一个变量的方式。

这里我们使用的JDK版本JDK8

原子更新基本类型

使用原子的方式更新基本类型，Atomic包提供了以下3个类。

AtomicBoolean：原子更新布尔类型
AtomicInteger：原子更新整型
AtomicLong：原子更新长整型

以AtomicInteger为例看下JDK8源码中提供的方法

列举几个常用的方法：

int addAndGet（int delta）：以原子方式将输入的数值与实例中的值（AtomicInteger里的 value）相加，并返回结果
boolean compareAndSet（int expect，int update）：如果输入的数值等于预期值，则以原子方式将该值设置为输入的值
int getAndIncrement()：以原子方式将当前值加1，注意，这里返回的是自增前的值
int incrementAndGet()：以原子方式将当前值加1，注意，这里返回的是自增后的值
void lazySet（int newValue）：最终会设置成newValue，使用lazySet设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值

Demo

package com.artisan.example.atomic;import java.util.concurrent.atomic.AtomicInteger;import lombok.extern.slf4j.Slf4j;@Slf4j
public class AtomicIntegerDemo {// 实例化一个初始值为5的AtomicIntegerprivate static AtomicInteger value = new AtomicInteger(5);public static void main(String[] args) {// 以原子方式将输入的数值与value 相加，并返回结果 log.info("value的值：{}" ,value.addAndGet(3));// 获取value的值log.info("value的值：{}",value.get());// 如果输入的数值等于预期值，则以原子方式将该值设置为输入的值log.info("执行结果：{}" ,value.compareAndSet(8, 11)); // 因为经过了addAndGet，操作之前value的值为8，这里会将value更新成11，返回truelog.info("执行结果：{}" ,value.compareAndSet(5, 11)); // 因为经过了addAndGet，操作之前value的值为8，并不等于5，因此不会更新为11，返回falselog.info("value的值：{}" ,value.get());log.info("value 增长前的值：{}",value.getAndIncrement());log.info("value的值：{}" ,value.get());log.info("value 增长后的值：{}",value.incrementAndGet());log.info("value的值：{}" ,value.get());//  最终会设置成newValue，使用lazySet设置值后，可能导致其他线程在之后的一小段时间内还是可以读到旧的值value.lazySet(99);log.info("lazyset value: {}",value.get());}
}

执行结果：

AtomicBoolean 场景举例

假设流程中的某个方法只能执行一次初始化操作，我们可以设置个flag, 使用AtomicBoolean去更新flag的值，执行方法前调用compareAndSet方法来判断如果该值为flase，更新为true，并执行该方法。因为是线程安全的，所以后续的访问flag均为true,不满足if条件，所以均不会执行该方法。

package com.artisan.example.atomic;import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicBoolean;import lombok.extern.slf4j.Slf4j;@Slf4j
public class AtomicBooleanDemo {//总请求数private static int clientTotal = 5000;// 同一时间允许执行的线程数private static int threadTotal = 200;// 标识  ，使用原子包中的AtomicBoolean  初始化为falseprivate static AtomicBoolean atomicBooleanFlag = new AtomicBoolean(false);public static void main(String[] args) throws Exception {// 线程池ExecutorService executorService = Executors.newCachedThreadPool();// 信号量 同一时间允许threadTotal个请求同时执行 即初始化threadTotal个信号量Semaphore semaphore = new Semaphore(threadTotal);//定义clientTotal个线程需要执行完，主线程才能继续执行CountDownLatch countDownLatch = new CountDownLatch(clientTotal);// 循环for (int i = 0; i < clientTotal; i++) {executorService.execute(() ->{try {semaphore.acquire();doSomething();semaphore.release();} catch (InterruptedException e) {e.printStackTrace();}// 减一countDownLatch.countDown();});}// 当全部线程都调用了countDown方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。countDownLatch.await();// 关闭线程池executorService.shutdown();log.info("flag:{}" ,atomicBooleanFlag.get());}private static void doSomething() {// 如果flag为flase就将其设置为trueif (atomicBooleanFlag.compareAndSet(false, true)) {log.info("doSomething executed");}}}

输出

原子更新数组

通过原子的方式更新数组里的某个元素，Atomic包提供了以下3个类。

AtomicIntegerArray : 原子更新整型数组里的元素
AtomicLongArray : 原子更新长整型数组里的元素
AtomicReferenceArray : 原子更新引用类型数组里的元素

我们以AtomicIntegerArray为例来演示下用法

常用方法

int addAndGet（int i，int delta）：以原子方式将输入值与数组中索引i的元素相加
boolean compareAndSet（int i，int expect，int update）：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值

Demo

package com.artisan.example.atomic;import java.util.concurrent.atomic.AtomicIntegerArray;import lombok.extern.slf4j.Slf4j;@Slf4j
public class AtomicIntegerArrayDemo {private static int[] array = new int[] { 11, 22 };private static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(array);public static void main(String[] args) {// 给array[0]的值增加33 ，然后返回增长后的值 44log.info("atomicIntegerArray addAndGet ：{}", atomicIntegerArray.addAndGet(0, 33)); // 44// 输出 atomicIntegerArray中log.info("atomicIntegerArray get ：{}", atomicIntegerArray.get(0)); // 44// 数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组 复制一份，// 所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组log.info("array[0]的值： {}", array[0]); // 11// 先get 然后再add ,返回add之前的值log.info("atomicIntegerArray getAndAdd ：{}", atomicIntegerArray.getAndAdd(0, 33)); // 44log.info("atomicIntegerArray .get(0) ：{}", atomicIntegerArray.get(0)); // 44+33log.info("array[0]的值： {}", array[0]); // 11// 先get ,然后再set,返回set之前的数据log.info("atomicIntegerArray getAndSet ：{}", atomicIntegerArray.getAndSet(0, 33));// 77log.info("atomicIntegerArray get(0) ：{}", atomicIntegerArray.get(0)); // 33log.info("array[0] ：{}", array[0]); // 11 }}

数组value通过构造方法传递进去，然后AtomicIntegerArray会将当前数组复制一份，所以当AtomicIntegerArray对内部的数组元素进行修改时，不会影响传入的数组

原子更新引用类型

原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子更新多个变量，就需要使用这个原子更新引用类型提供的类.

Atomic包提供了以下3个类

AtomicReference：原子更新引用类型
AtomicReferenceFieldUpdater：原子更新引用类型里的字段
AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型

以AtomicReference为例，来看下用法

Demo

package com.artisan.example.atomic;import java.util.concurrent.atomic.AtomicReference;import lombok.extern.slf4j.Slf4j;@Slf4j
public class AtomicReferenceDemo {private static AtomicReference<Artisan> atomicReferenceArtisan = new AtomicReference<Artisan>();public static void main(String[] args) {Artisan expectedArtisan = new Artisan();expectedArtisan.setName("小工匠");expectedArtisan.setAge(20);// 将expectedArtisan设置到atomicReferenceArtisanatomicReferenceArtisan.set(expectedArtisan);Artisan updateArtisan = new Artisan();updateArtisan.setName("小工匠Update");updateArtisan.setAge(99);// compareAndSet方法进行原子更新操作,如果是expectedArtisan，则更新为updateArtisanboolean mark2 = atomicReferenceArtisan.compareAndSet(new Artisan(), updateArtisan);log.info("更新是否成功：{}", mark2);// falseboolean mark = atomicReferenceArtisan.compareAndSet(expectedArtisan, updateArtisan);log.info("更新是否成功：{}", mark); // truelog.info("atomicReferenceArtisan name:{}", atomicReferenceArtisan.get().getName());log.info("atomicReferenceArtisan age：{}", atomicReferenceArtisan.get().getAge());}}

结果

原子更新字段类型

如果需原子地更新某个类里的某个字段时，就需要使用原子更新字段类.

Atomic包提供了以下3个类进行原子字段更新

AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。
AtomicLongFieldUpdater：原子更新长整型字段的更新器。
AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更新数据和数据的版本号，可以解决使用CAS进行原子更新时可能出现的ABA问题。

使用注意事项：

第一：因为原子更新字段类都是抽象类，每次使用的时候必须使用静态方法newUpdater()创建一个更新器，并且需要设置想要更新的类和属性
第二：更新类的字段（属性）必须使用public volatile修饰符

Demo

package com.artisan.example.atomic;import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;import lombok.extern.slf4j.Slf4j;@Slf4j
public class AtomicIntegerFieldUpdaterDemo {// 创建原子更新器，并设置需要更新的对象类和对象的属性private static AtomicIntegerFieldUpdater<Artisan2> atomicIntegerFieldUpdaterArtisan = AtomicIntegerFieldUpdater.newUpdater(Artisan2.class, "age");public static void main(String[] args) {Artisan2 artisan = new Artisan2();artisan.setAge(20);log.info("目前atomicIntegerFieldUpdaterArtisan中age的值为:{}",atomicIntegerFieldUpdaterArtisan.get(artisan));if (atomicIntegerFieldUpdaterArtisan.compareAndSet(artisan, 20, 99)) {log.info("artisan的age属性的值期望为20，则将20更新为99，更新成功");}// 获取artisan更新后的age的值log.info("目前atomicIntegerFieldUpdaterArtisan中age的值为:{}",atomicIntegerFieldUpdaterArtisan.get(artisan));if (atomicIntegerFieldUpdaterArtisan.compareAndSet(artisan, 20, 99)) {log.info("artisan的age属性的值期望为20，则将20更新为99，更新成功");}else {log.info("artisan的age属性的值期望为20，则将20更新为99，更新失败. 目前age的值为：{}",atomicIntegerFieldUpdaterArtisan.get(artisan));}}
}

package com.artisan.example.atomic;import lombok.Data;@Data
public class Artisan2 {String name;public volatile int age;
}

结果：

原子类线程安全的原理

请参考上篇博客，主要是UnSafe 以及compareAndSwapInt ( CAS). 【JDK8和8以前的实现方式略有不同】
https://blog.csdn.net/yangshangwei/article/details/87489745#incrementAndGetUnSafe__compareAndSwapInt_CAS_54

代码

https://github.com/yangshangwei/ConcurrencyMaster

并发编程-04线程安全性之原子性Atomic包的4种类型详解相关推荐

并发编程-03线程安全性之原子性（Atomic包）及原理分析
文章目录线程安全性文章索引脑图线程安全性的定义线程安全性的体现原子性使用AtomicInteger改造线程不安全的变量 incrementAndGet源码分析-UnSafe类 compar ...
并发编程-05线程安全性之原子性【锁之synchronized】
文章目录线程安全性文章索引脑图概述原子性synchronized 修饰的4种对象修饰代码块作用范围及作用对象 Demo 多线程下同一对象的调用多线程下不同对象的调用修饰方法作用范围 ...
Atomic包的4种类型详解
Java从JDK1.5开始提供了java.util.concurrent.atomic包,方便程序员在多线程环境下,无锁的进行原子操作.原子变量的底层使用了处理器提供的原子指令,但是不同的CPU架构可 ...
并发编程-06线程安全性之可见性 (synchronized + volatile)
文章目录线程安全性文章索引脑图可见性定义导致不可见的原因可见性 -synchronized (既保证原子性又保证可见性) 可见性 - volatile(但不保证操作的原子性) volatil ...
java 线程安全list_JAVA并发编程实战-线程安全性
线程安全性: 对象的状态是指存储在状态变量(例如实例和静态域)中的数据. 对象的状态可能包括其他依赖对象的域. 例如:某个HashMap的状态不仅存储在HashMap对象本身,还存储在许多Map.En ...
Java并发编程之线程安全性分析之原子性、可见性、有序性
一:线程的安全性分析如何理解线程安全: 当多个线程访问某个共享对象时,不管运行环境采用何种调度方式,或者这些线程如何交替执行,并且主调代码中不需要任何的额外同步操作或者协同操作,这个类都能表现出正确 ...
并发编程 (三) 线程安全性之避免线程不安全
文章目录一.如何保证线程安全 1.1.并发原子类 1.2.加锁机制 1.3.信号量同步共享数据 1.4.封闭线程,不共享数据 1.5.发布与逸出二.设计线程安全的类 2.1.前提要素 2.2.无限 ...
java并发编程与线程安全
2019独角兽企业重金招聘Python工程师标准>>> 什么是线程安全如果对象的状态变量(对象的实例域.静态域)具有可变性,那么当该对象被多个线程共享时就的考虑线程安全性的问题,否 ...
并发编程-12线程安全策略之常见的线程不安全类
文章目录脑图概述字符串拼接子之StringBuilder.StringBuffer StringBuilder (线程不安全) StringBuffer (线程安全) 小结时间相关的类 Sim ...

并发编程-04线程安全性之原子性Atomic包的4种类型详解

文章目录

线程安全性文章索引

脑图

概述

原子更新基本类型

Demo

AtomicBoolean 场景举例

原子更新数组

Demo

原子更新引用类型

Demo

原子更新字段类型

使用注意事项：

Demo

原子类线程安全的原理

代码

并发编程-04线程安全性之原子性Atomic包的4种类型详解相关推荐

最新文章

热门文章