Java中CAS算法的集中体现：Atomic原子类库，你了解吗？

JavaBuild2024-05-20 22:17

一、写在开头

在前面的博文中我们学习了volatile关键字，知道了它可以保证有序性和可见性，但无法保障原子性，结局原子性问题推荐使用synchronized、Lock或者AtomicInteger；我们还学习过CAS算法，在那篇博文中我们同样也提及atomic。那么今天，我们就来好好学一学Atomic原子库，一个基于CAS算法实现的高效并发工具库！

并发包 java.util.concurrent 的原子类都存放在java.util.concurrent.atomic中，如下图所示：

1.1 Atomic释义

Atomic翻译为"原子"，何为原子？在化学领域的原子被认为是构成化学反应的最小微观粒子，是不可分割的最小单位（当然后面又发现了更小的粒子，咱们不杠哈），伟大的Doug Lea大师，将并发的一些类以此单词开头命名，一语中的！

  • 原子性在程序中所表达的意思是：一个或者多个操作在 CPU 执行的过程中不被中断的特性！
  • 原子操作在程序中表达的意思是：即最小不可拆分的操作，也就是说操作一旦开始，就不能被打断，直到操作完成！

二、四大原子分类

我们根据操作的数据类型可以将JUC包中的原子类做如下的4种划分：

2.1 基本类型

原子操作的基本类型主要可分为：

  1. AtomicBoolean：布尔型原子类；
  2. AtomicInteger：整型原子类；
  3. AtomicLong：长整型原子类；

这三种方式用法几乎相同，都是以原子更新的方式操作基本类型，我们在这里以AtomicInteger为例看一下它的使用与原理。

1）AtomicInteger的常用方法

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

2）AtomicInteger的使用案例

java 复制代码 
public class Test {
    public static void main(String[] args) {
        //临时值
        int temvalue = 0;
        AtomicInteger i = new AtomicInteger(0);
        temvalue = i.getAndSet(3);
        System.out.println("temvalue:" + temvalue + ";  i:" + i); //temvalue:0;  i:3
        temvalue = i.getAndIncrement();
        System.out.println("temvalue:" + temvalue + ";  i:" + i); //temvalue:3;  i:4
        temvalue = i.getAndAdd(5);
        System.out.println("temvalue:" + temvalue + ";  i:" + i); //temvalue:4;  i:9
        temvalue = i.incrementAndGet();
        System.out.println("temvalue:" + temvalue + ";  i:" + i); //temvalue:10;  i:10
    }
}

这里面需要注意的一点是getAndIncrement()方法与incrementAndGet()，一个先获值后自增，一个先自增后获值。

3）AtomicInteger的底层原理

我们以getAndIncrement()为例，去跟入它的底层代码会发现，其内部是同调佣UnSafe类的静态方法 getUnsafe 实现的，UnSafe类我们在讲解CAS算法的时候有提及，后面找个时间再单独学一下它，其底层是通过CAS，原子性的进行增加值。

java 复制代码 
public final int getAndIncrement() {
    // 使用Unsafe类中的getAndAddInt方法原子地增加AtomicInteger的当前值
    // 第一个参数this是AtomicInteger的当前实例
    // 第二个参数valueOffset是一个偏移量，它指示在AtomicInteger对象中的哪个位置可以找到实际的int值
    // 第三个参数1表示要加到当前值上的值（即增加的值）
    // 此方法返回的是增加前的原始值
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

Unsafe 类是 Java 中的一个特殊类，用于执行低级、不安全的操作。getAndIncrement 方法就是利用了 Unsafe 类提供的 CAS（Compare-And-Swap）操作来实现原子的 increment 操作。CAS 是一种常用的无锁技术，允许在多线程环境中原子地更新值。

2.2 数组类型

原子操作根据数组类型，可以分为如下几种：

  1. AtomicIntegerArray：整形数组原子类
  2. AtomicLongArray：长整形数组原子类
  3. AtomicReferenceArray：引用类型数组原子类

这三种同样很类似，我们以AtomicIntegerArray为例来介绍一下。

1）AtomicIntegerArray的常用方法

java 复制代码 
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 i, int delta) //获取 index=i 位置元素的值，并加上预期的值
boolean compareAndSet(int i, int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）
public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

2）AtomicIntegerArray的使用案例

java 复制代码 
public class Test {
    public static void main(String[] args) {
        int temvalue = 0;
        int[] nums = { 1, 2, 3, 4, 5, 6 };
        AtomicIntegerArray i = new AtomicIntegerArray(nums);
        for (int j = 0; j < nums.length; j++) {
            System.out.print(i.get(j));
        }
        System.out.println();
        temvalue = i.getAndSet(0, 2);
        System.out.println("temvalue:" + temvalue + ";  i:" + i);
        temvalue = i.getAndIncrement(0);
        System.out.println("temvalue:" + temvalue + ";  i:" + i);
        temvalue = i.getAndAdd(0, 5);
        System.out.println("temvalue:" + temvalue + ";  i:" + i);
    }
}

输出：

java 复制代码 
123456
temvalue:1;  i:[2, 2, 3, 4, 5, 6]
temvalue:2;  i:[3, 2, 3, 4, 5, 6]
temvalue:3;  i:[8, 2, 3, 4, 5, 6]

2.3 引用类型

除了如上的2种原子类外，atomic包中还提供了引用类型原子类。大概为如下几种：

  1. AtomicReference：原子更新引用类型，使用AtomicReference类保证对象之间的原子性，把多个变量放到一个对象里面进行 CAS 操作；
  2. AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题；
  3. AtomicMarkableReference：原子更新带有标记的引用类型，该类将 boolean 标记与引用关联起来。

常用方法又上述两种类型一致，这里不再赘述，我们直接写一个demo感受一下它的使用吧

java 复制代码 
public class TestAtomicReference {

    private static AtomicReference<User> reference = new AtomicReference<>();

    public static void main(String[] args) {
        User user1 = new User("小明", 18);
        reference.set(user1);
        User user2 = new User("小华",20);
        User user = reference.getAndSet(user2);
        System.out.println(user);
        System.out.println(reference.get());
    }

    static class User {
        private String userName;
        private int age;

        public User(String userName, int age) {
            this.userName = userName;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "userName='" + userName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

输出：

java 复制代码 
User{userName='小明', age=18}
User{userName='小华', age=20}

通过结果我们可以看出先给该reference引用对象set一个user1，再通过getAndSet()方法进行赋值，先输出当前对象数据，紧接着引用指向最新的对象地址，也就是"User{userName='小华', age=20}"。

2.4 对象的属性修改类型

除了原子更新对象（引用类型）外，atomic中还提供了更新对象的属性字段的原子类：

  1. AtomicIntegerFieldUpdater:原子更新整形字段的更新器；
  2. AtomicLongFieldUpdater：原子更新长整形字段的更新器；
  3. AtomicReferenceFieldUpdater：原子更新引用类型里的字段的更新器。

如果想要原子的更新对象的属性，实现起来较上面几种类型略微复杂一下，大概分为两步；

步骤1️⃣： 通过静态方法newUpdater创建一个更新器，并且设置想要更新的类和字段；

步骤2️⃣： 字段必须使用public volatile进行修饰；

以 AtomicIntegerFieldUpdater为例，我们写一个测试类感受一下。

java 复制代码 
public class TestAtomicIntegerFieldUpdater {
    //创建一个age的更新器
    private static AtomicIntegerFieldUpdater updater = AtomicIntegerFieldUpdater.newUpdater(User.class,"age");

    public static void main(String[] args) {
        User user = new User("小明", 17);
        int oldValue = updater.getAndAdd(user, 1);
        System.out.println(oldValue);//17
        System.out.println(updater.get(user));//18
    }

    static class User {
        private String userName;
        public volatile int age;

        public User(String userName, int age) {
            this.userName = userName;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "userName='" + userName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

通过AtomicIntegerFieldUpdater.newUpdater(User.class,"age")创建一个age的更新器，然后调用getAndAdd(user, 1)进行年龄加1操作，从17岁变为18岁。

三、结尾彩蛋

如果本篇博客对您有一定的帮助，大家记得留言+点赞+收藏呀。原创不易，转载请联系Build哥！

如果您想与Build哥的关系更近一步，还可以关注"JavaBuild888"，在这里除了看到《Java成长计划》系列博文，还有提升工作效率的小笔记、读书心得、大厂面经、人生感悟等等，欢迎您的加入！

相关推荐
小_太_阳15 分钟前
Scala_【1】概述
开发语言·后端·scala·intellij-idea
智慧老师24 分钟前
Spring基础分析13-Spring Security框架
java·后端·spring
lxyzcm26 分钟前
C++23新特性解析：[[assume]]属性
java·c++·spring boot·c++23
V+zmm101341 小时前
基于微信小程序的乡村政务服务系统springboot+论文源码调试讲解
java·微信小程序·小程序·毕业设计·ssm
Oneforlove_twoforjob1 小时前
【Java基础面试题025】什么是Java的Integer缓存池？
java·开发语言·缓存
xmh-sxh-13141 小时前
常用的缓存技术都有哪些
java
搬码后生仔2 小时前
asp.net core webapi项目中 在生产环境中 进不去swagger
chrome·后端·asp.net
凡人的AI工具箱2 小时前
每天40分玩转Django：Django国际化
数据库·人工智能·后端·python·django·sqlite
AiFlutter2 小时前
Flutter-底部分享弹窗（showModalBottomSheet）
java·前端·flutter
J不A秃V头A2 小时前
IntelliJ IDEA中设置激活的profile
java·intellij-idea
热门推荐
01【一文读懂】NTN（非地面网络）技术介绍02优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间03玄机平台应急响应—webshell查杀04Cube-Studio：开源大模型全链路一站式中台05基于大语言模型（LLM）的合成数据生成、策展和评估的综述06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07组基轨迹建模 GBTM的介绍与实现（Stata 或 R）08HCIA-datacom数通题库和录播视频资料09Docker 夺命连环 15 问10RAG 实践- Ollama+RagFlow 部署本地知识库