重温java知识（三十九、JUC并发编程之三：原子操作类）

最新推荐文章于 2024-09-30 20:09:33 发布
最新推荐文章于 2024-09-30 20:09:33 发布
阅读量124 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuzhiboyouzhu/article/details/106504063
版权

在多线程操作中经常会出现多个线程对一个共享变量的并发修改，为了保证此操作的正确性，最初的时候可以通过synchronized关键字操作。JDK1.5之后，可以通过java.util.concurrent.atomic包中的原子操作类来操作。
此包中提供的原子操作类可以分为4类：

  • 基本类型：AtomicInteger、 AtomicLong、 AtomicBoolean。
  • 数组类型：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray。
  • 引用类型：AtomicReference、AtomicStampedReference【带有引用版本号的】、 AtomicMarkableReference【标记节点】。
  • 对象的属性修改类型：AtomicIntegerFieldFupdater、 AtomicLongFieldUpdater、AtomicReferenceFieldUpdater。

原子操作类最大的特点是可以进行线程安全更新，即帮助用户使用一种更为简单的共享数据的线程同步处理操作，所以通过源代码，我们可以发现，在这些原子类数据保存属性上都使用类volatile关键字进行声明，这样就可以防止由于数据缓存所造成的数据更新不一致的问题。

1-1、【基本类型】使用AtomicLong进行原子性操作的例子：

package com.mydemo;

import java.util.concurrent.atomic.AtomicLong;

public class JUCDemo {

    public static void main(String[] args) {

        // 实例化原子操作类
        AtomicLong atomicLong = new AtomicLong(100l);

        // 增加数据并取得
        atomicLong.addAndGet(200);

        // 先获取而后再自增
        long current = atomicLong.getAndIncrement();

        // 自增前的内容
        System.out.println(current);

        // 自增后的内容
        System.out.println(atomicLong.get());
    }
}

运行结果：
300
301

1-2、【基本类型】利用多线程操作的例子：

package com.mydemo;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

public class JUCDemo {

    public static void main(String[] args) {
        // 实例化原子操作类
        AtomicLong atomicLong = new AtomicLong(100);
        for (int i = 0; i < 10; i++) {
            new Thread(
                    () -> {
                        // 增加数据并取得
                        atomicLong.addAndGet(200);
                    }
            ).start();
        }
        // 休眠2秒，等待执行结果
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 自增后的内容
        System.out.println(atomicLong.get());
    }
}

运行结果：
2100

1-3、【基本类型】判断并设置新内容的例子：

package com.mydemo;

import java.util.concurrent.atomic.AtomicLong;

public class JUCDemo {

    public static void main(String[] args) {

        // 实例化原子操作类
        AtomicLong atomicLong = new AtomicLong(100l);

        // 内容相同，返回true
        System.out.println(atomicLong.compareAndSet(100l, 300l));

        // 取出数据
        System.out.println(atomicLong.get());
    }
}

运行结果：
true
300

2-1、【数组类型】使用AtomicReferenceArray类操作的例子：

package com.mydemo;

import java.util.concurrent.atomic.AtomicReferenceArray;

public class JUCDemo {

    public static void main(String[] args) {
        String infos[] = new String[]{
                "www.baidu.com",
                "www.google.com",
                "www.alibaba.com"
        };
        AtomicReferenceArray<String> atomicReferenceArray = new AtomicReferenceArray<>(infos);
        /**
         * 在使用compareAndSet()方法进行比较时，是通过“==”方式实现的比较操作
         *
         * 原因：
         * 由底层C语言实现的。
         * 该类操作是基于地址指针的形式处理的，所以只允许通过“==”进行地址判断
         */
        System.out.println(atomicReferenceArray.compareAndSet(0, "www.baidu123.com", "www.test.com"));
        System.out.println(atomicReferenceArray.compareAndSet(1, "www.google.com", "www.test.com"));
        // 输出
        System.out.println(atomicReferenceArray.get(0));
        System.out.println(atomicReferenceArray.get(1));
    }
}

运行结果：
false
true
www.baidu.com
www.test.com

3-1、【引用类型】使用AtomicReference类操作引用数据的例子：

package com.mydemo;

import java.util.concurrent.atomic.AtomicReference;

public class JUCDemo {

    public static void main(String[] args) {

        // 实例化Member实例
        Member memberA = new Member("张三", 18);
        Member memberB = new Member("李四", 20);

        AtomicReference<Member> atomicReference = new AtomicReference<>(memberA);

        // 修改当前保存数据
        atomicReference.compareAndSet(memberA, memberB);

        // 输出当前数据内容
        System.out.println(atomicReference);
    }
}

class Member {
    private String name;
    private int age;

    public Member(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Member{" +
                "姓名：'" + name + '\'' +
                ", 年龄：" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

运行结果：
Member{姓名：'李四', 年龄：20}

3-2、【引用类型】使用AtomicStampedReference类进行引用原子性操作的例子：

package com.mydemo;

import java.util.concurrent.atomic.AtomicStampedReference;

public class JUCDemo {

    public static void main(String[] args) {

        // 实例化Member实例
        Member memberA = new Member("张三", 18);
        Member memberB = new Member("李四", 20);

        // 由于AtomicStampedReference需要提供版本号，所以在初始化时定义版本号为1
        AtomicStampedReference<Member> atomicStampedReference =
                new AtomicStampedReference<>(memberA, 1);

        // 在进行CAS操作时除了要设置替换内容外，
        // 也需要设置正确的版本号，否则无法替换。
        atomicStampedReference.compareAndSet(memberA, memberB, 1, 2);

        // 输出当前数据内容
        System.out.println(atomicStampedReference.getReference());

        // 获取版本号
        System.out.println(atomicStampedReference.getStamp());
    }
}

class Member {
    private String name;
    private int age;

    public Member(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Member{" +
                "姓名：'" + name + '\'' +
                ", 年龄：" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

运行结果：
Member{姓名：'李四', 年龄：20}
2

3-3、【引用类型】使用AtomicMarkableReference类进行标记原子性操作的例子：

package com.mydemo;

import java.util.concurrent.atomic.AtomicMarkableReference;

public class JUCDemo {

    public static void main(String[] args) {

        // 实例化Member实例
        Member memberA = new Member("张三", 18);
        Member memberB = new Member("李四", 20);

        // 由于AtomicMarkableReference需要提供标记位才可以进行判断
        AtomicMarkableReference<Member> atomicMarkableReference =
                new AtomicMarkableReference<>(memberA, true);

        // 在进行CAS操作时除了要设置替换内容外，
        // 也需要设置标记号，否则无法替换。
        atomicMarkableReference.compareAndSet(memberA, memberB, true, false);

        // 输出当前数据内容
        System.out.println(atomicMarkableReference.getReference());
    }
}

class Member {
    private String name;
    private int age;

    public Member(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Member{" +
                "姓名：'" + name + '\'' +
                ", 年龄：" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

运行结果：
Member{姓名：'李四', 年龄：20}

4-1、【对象的属性修改类型】实现属性操作的例子：

package com.mydemo;

import java.util.concurrent.atomic.AtomicLongFieldUpdater;

public class JUCDemo {

    public static void main(String[] args) {

        Book book = new Book(1001, "java从入门到放弃");
        book.setId(2003);
        System.out.println(book);
    }
}

class Book {

    /**
     * 必须使用volatile定义
     * 否则将会出现IllegalArgumentException异常
     */
//    private long id;
    private volatile long id;
    private String title;

    public Book(long id, String title) {
        this.id = id;
        this.title = title;
    }

    @Override
    public String toString() {
        return "Book{" +
                "id：" + id +
                ", 名称：'" + title + '\'' +
                '}';
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
//        this.id = id;
        AtomicLongFieldUpdater<Book> atomicLongFieldUpdater =
                AtomicLongFieldUpdater.newUpdater(Book.class, "id");
        atomicLongFieldUpdater.compareAndSet(this, this.id, id);
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }
}

运行结果:
Book{id：2003, 名称：'java从入门到放弃'}

4-2、【对象的属性修改类型】并发计算的例子：

package com.mydemo;

import java.util.concurrent.atomic.DoubleAccumulator;

public class JUCDemo {

    public static void main(String[] args) {

        /**
         * 原子性的累加器只适合于进行基础的数据统计，
         * 并不适用于其他更加细粒度的操作。
         */

        // 累加器
        DoubleAccumulator doubleAccumulator = new DoubleAccumulator(
                (x, y) -> x + y, 1.1
        );

        // 原始内容
        System.out.println(doubleAccumulator.doubleValue());

        // 加法计算
        doubleAccumulator.accumulate(20);

        // 获取数据
        System.out.println(doubleAccumulator.get());

    }
}

运行结果：
1.1
21.1

4-3、【对象的属性修改类型】使用加法器计算的例子：

package com.mydemo;

import java.util.concurrent.atomic.DoubleAdder;

public class JUCDemo {

    public static void main(String[] args) {

        // 定义加法器
        DoubleAdder doubleAdder = new DoubleAdder();

        // 数据执行加法
        doubleAdder.add(10);
        doubleAdder.add(20);
        doubleAdder.add(30);

        // 数据累加
        System.out.println(doubleAdder.sum());
    }
}

运行结果：
60.0
宇智波幽助
关注
专栏目录
『死磕Java并发编程系列』并发编程工具类之CountDownLatch
华科硕士，大厂打工中。编程问题咨询，请私我
09-14 3617
《死磕 Java 并发编程》系列连载中，大家可以关注一波： ????????『死磕Java并发编程系列』 01 十张图告诉你多线程那些破事 『死磕Java并发编程系列』 02 面试官：说说什么是Java内存模型？ 『死磕Java并发编程系列』 03 面试必问的CAS原理你会了吗？ 『死磕Java并发编程系列』 04 面试官：说说Atomic原子类的实现原理？ ????????『死磕Java并发编程系列』 05 图解Java中那18 把锁 在日常编码中，Java 并发编程可是少不了，试试下面这些并
java经典面试题JUC并发篇（持续更新）
呆萌小新@渊洁的博客
11-08 3640
什么是ABA：在CAS过程中，线程1、线程2分别从内存中拿到了当前值为A，同时线程2把当前值A改为B，随后又把B改回来变为A，此后线程1检查到当前值仍为A而导致执行cas成功，但这个过程却发生了ABA问题，现场资源可能和当初不一样了(线程2把当前值由A->B->A)解决方法：版本号机制，利用版本号标记线程1拿到的‘当前值’的版本，若线程2进行了A->B->A操作，则版本号会改变，那线程1再次拿到的‘当前值’的版本和第一次的肯定是不同的，从而判定cas失败；解释器JIT对热点代码的优化。
java高并发程序设计：JUC
qq_42673707的博客
09-08 503
《实战java高并发程序设计》第三章草记 文章目录《实战java高并发程序设计》第三章草记前言一、多线程的团队协作：同步控制1.1重入锁一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 本文为作者学
Day823.Java原子性问题解决方案 -Java 并发编程实战
阿昌爱Java
12-07 277
Hi，我是，今天学习记录的是关于。在并发编程Bug的源头中提到，一个或者多个操作在 CPU 执行的过程中不被中断的特性，称为“”。理解这个特性有助于分析并发编程 Bug 出现的原因，例如利用它可以分析出 long 型变量在 32 位机器上读写可能出现的诡异 Bug，明明已经把变量成功写入内存，重新读出来却不是自己写入的。那原子性问题到底该如何解决呢？原子性问题的源头是线程切换，如果能够禁用线程切换那不就能解决这个问题了吗？操作系统做线程切换是依赖 CPU 中断的，所以禁止 CPU 发生中断就能够禁止线程切换
2021不可错过的并发编程篇：知识图鉴+知识点剖析+高频面试+书籍
m0_59090040的博客
07-05 124
知识图鉴（我真的尽力清晰了） 知识点剖析 1、JAVA 并发知识库 2、JAVA 线程实现/创建方式 3、4 种线程池 Java 里面线程池的顶级接口是Executor，但是严格意义上讲 Executor 并不是一个线程池，而 只是一个执行线程的工具。真正的线程池接口是ExecutorService。 4、线程生命周期(状态) 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。 在线程的生命周期中，它要经过新建(New)、就..
Java并发编程第4讲——Java中的锁（万字详解）
让~学习~成为一种习惯（橡 皮 人の技术博客）
08-11 2124
本篇文章介绍了Java中的6种锁。从锁的相关概念开始，逐一详细介绍synchronized关键字、ReentrantLock、Condition接口、读写锁ReentrantReadWriteLock、读写性能之王StampedLock以及CAS乐观锁。内容涉及各个的概念、实现原理、特性、常用方法、代码示例以及相互之间的比较。
【Java多线程】JUC之显示锁(Lock)与初识AQS(队列同步器)
m0_64354070的博客
11-27 390
文章目录 一.前言 并发编程最佳学习路线 【Java基础】多线程从入门到掌握 【Java多线程】线程通信 【Java多线程】JUC之CAS机制与原子类型(Atomic) 【Java多线程】JUC之Java并发包Concurrent发展简述(各版本JDK中的并发技术) 了解高并发必须知道的概念 【Java多线程】高并发修炼基础之高并发必须了解的概念 了解Java并发包Concurrent发展简述 【Java多线程】JUC之Java并发包Concurrent发展简述(各版本JDK中的
JUC实战必备-全是精华
weixin_43206491的博客
11-22 856
????JUC 简介 JAVA 在 1.5版本中引入了 java.util.concurrent工具包，JUC 就是它的简称，用于处理线程的工具包。 ????重温进程与线程 进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程——资源分配的最小单位。 线程：系统分配处理器时间资源的基本单元，或者说进程之内独立执行的一个单元执行流。线程——程序执行的最小单位。 线程的状态 NEW：新建 RUNNABLE：准备就绪 BLOCKED：阻塞 WAITING：等待（不见不散） TIMED_WAITIN
从JVM角度理解Java并发（下）
Yungang_Young的博客
08-10 1101
本文内容主要参考黑马JUC并发编程，《Java并发编程的艺术》，所有代码可在github我的主页下载。在第二章我们学习了锁的相关知识，认识到了Moniter，实际上，正是它保证了临界区代码的原子性（即使线程切换，它也能占据临界区的锁，不会被干扰），JMM主要体现在以下三个方面，本章我们继续介绍后续的可见性和有序性。前面学习的synchronized能有效实现原子性，可见性，以及能从逻辑上实现有序性（毕竟代码块内相当于单线程，即使无序也不会出现线程干扰），但synchronized始终是锁，有没有更轻量的方式
工厂模式的介绍及实现
户伟伟的博客
09-25 154
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 555
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 423
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
JPA+Thymeleaf增删改查
y050505的博客
09-25 502
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 997
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 291
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1083
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
【RocketMQ】RocketMQ应用难点
最新发布
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 617
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值