Java并发编程之原子操作类Atomic*

最新推荐文章于 2023-09-20 19:55:34 发布
最新推荐文章于 2023-09-20 19:55:34 发布
阅读量403 收藏 1
点赞数
分类专栏： 多线程 并发编程 文章标签： 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43654581/article/details/124274684
版权

1、原子更新基本类型

AtomicInteger 原子更新整型

主要方法

	//返回当前值
	 public final int get() {
        return value;
    }
	
	//设置为给定值
    public final void set(int newValue) {
        value = newValue;
    }
    
	//原子设置为给定值并返回旧值。
    public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }
	
	//比较当前值=预期值，则自动将该值设置为给定的更新值
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

	//以原子方式将当前值递增1，返回更新前的值
    public final int getAndIncrement() {
        return unsafe.getAndAddInt(this, valueOffset, 1);
    }

    //以原子方式将当前值递增1，返回更新后的值
    public final int incrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
    }

	//以原子方式将当前值递减1，返回更新前的值
    public final int getAndDecrement() {
        return unsafe.getAndAddInt(this, valueOffset, -1);
    }

	//以原子方式将当前值递减1，返回更新后的值
    public final int decrementAndGet() {
        return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
    }
    
    //以原子方式将给定值与当前值相加，返回更新前的值
    public final int getAndAdd(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta);
    }
    
    //以原子方式将给定值与当前值相加，返回更新后的值
	public final int addAndGet(int delta) {
        return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
    }

示例1 最终结果不一致问题

    public static int a = 0;

    private static void demo01() {
        Thread t1 = new Thread(AtomicDemo::method01, "t1");
        Thread t2 = new Thread(AtomicDemo::method01, "t2");
        Thread t3 = new Thread(AtomicDemo::method01, "t3");
        t1.start();
        t2.start();
        t3.start();

        while (Thread.activeCount() > 1) Thread.yield();
        System.out.println(a);
    }

    private static void method01() {
        String thName = Thread.currentThread().getName();
        System.err.println("线程：" + thName + " >> " + a);
        for (int i = 0; i < 1000; i++) {
            a++;
        }
        System.out.println("线程：" + thName + " >> " + a);
    }

多次测试，不能保证结果一致性
在这里插入图片描述

可以通过添加 synchronized 关键字同步方法来保证一致性，但synchronized属重量级锁，耗性能。

    private synchronized static void method01() {
        String thName = Thread.currentThread().getName();
        System.err.println("线程：" + thName + " >> " + a);
        for (int i = 0; i < 1000; i++) {
            a++;
        }
        System.out.println("线程：" + thName + " >> " + a);
    }

示例2 原子操作类AtomicInteger

    public static AtomicInteger b = new AtomicInteger();

    private static void demo02() {
        Thread t1 = new Thread(AtomicDemo::method02, "t1");
        Thread t2 = new Thread(AtomicDemo::method02, "t2");
        Thread t3 = new Thread(AtomicDemo::method02, "t3");
        t1.start();
        t2.start();
        t3.start();

        while (Thread.activeCount() > 1) Thread.yield();
        System.out.println(b.get());
    }

    private static void method02() {
        String thName = Thread.currentThread().getName();
        System.err.println("线程：" + thName + " >> " + b.get());
        for (int i = 0; i < 1000; i++) {
            b.incrementAndGet();
        }
        System.out.println("线程：" + thName + " >> " + b.get());
    }

多次测试，能保证结果一致性
在这里插入图片描述

AtomicLong：原子更新长整型

AtomicBoolean：原子更新布尔类型

2、原子更新引用类型

AtomicReference：原子更新引用类型

主要方法

	//获取当前值
    public final V get() {
        return value;
    }

	//设置为给定值
    public final void set(V newValue) {
        value = newValue;
    }

	//比较当前值=预期值，则自动将该值设置为给定的更新值。
    public final boolean compareAndSet(V expect, V update) {
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
    }

	//原子设置为给定值并返回旧值
    public final V getAndSet(V newValue) {
        return (V)unsafe.getAndSetObject(this, valueOffset, newValue);
    }

    private static void demo03() {
        AtomicReference<String> ars = new AtomicReference<>("字符串");
        System.out.println(ars.get());
        ars.compareAndSet("预期值", "更新值");
        System.out.println(ars.get());
        //或者实体类、数组等
        //AtomicReference<AtomicDemo> ars2 = new AtomicReference<>(new AtomicDemo());
    }

AtomicMarkableReference：原子更新一个对象引用和一个标记位

主要方法

	//返回引用的当前值
    public V getReference() {
        return pair.reference;
    }
	
	//返回标记的当前值
    public boolean isMarked() {
        return pair.mark;
    }

	//如果当前引用等于预期引用，则原子地将标记的值设置为给定的更新值
	public boolean attemptMark(V expectedReference, boolean newMark) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            (newMark == current.mark ||
             casPair(current, Pair.of(expectedReference, newMark)));
    }

	//如果当前引用等于预期引用，且当前标记等于预期标记，则原子地将引用和标记的值都设置为给定的更新值
	public boolean compareAndSet(V       expectedReference,
                                 V       newReference,
                                 boolean expectedMark,
                                 boolean newMark) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            expectedMark == current.mark &&
            ((newReference == current.reference &&
              newMark == current.mark) ||
             casPair(current, Pair.of(newReference, newMark)));
    }

    private static void demo04() {
        AtomicMarkableReference<Integer> amsi = new AtomicMarkableReference<>(0, false);
        System.out.println("更新前：" + amsi.isMarked());
        System.out.println("更新前：" + amsi.getReference());

        //未被标记，进行标志
        if (!amsi.isMarked() && amsi.attemptMark(0,true)) {
            //更新
            if (amsi.compareAndSet(0, 1, true, false)) {
                System.out.println("更新成功");
            } else {
                System.out.println("更新失败");
            }
        }

        System.out.println("更新后：" + amsi.isMarked());
        System.out.println("更新后：" + amsi.getReference());
    }

在这里插入图片描述

AtomicStampedReference：原子更新一个对象引用和一个整型

主要方法

	//返回引用的当前值
    public V getReference() {
        return pair.reference;
    }
	//返回戳记的当前值
    public int getStamp() {
        return pair.stamp;
    }
	//如果当前引用等于预期引用，则原子地将戳记的值设置为给定的更新值
	public boolean attemptStamp(V expectedReference, int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            (newStamp == current.stamp ||
             casPair(current, Pair.of(expectedReference, newStamp)));
    }
    //如果当前引用等于预期引用，且当前戳记等于预期戳记，则原子地将引用和戳记的值都设置为给定的更新值
    public boolean compareAndSet(V   expectedReference,
                                 V   newReference,
                                 int expectedStamp,
                                 int newStamp) {
        Pair<V> current = pair;
        return
            expectedReference == current.reference &&
            expectedStamp == current.stamp &&
            ((newReference == current.reference &&
              newStamp == current.stamp) ||
             casPair(current, Pair.of(newReference, newStamp)));
    }

    private static void demo05() {
        AtomicStampedReference<String> asrs = new AtomicStampedReference<>("初始值", 1);
        System.out.println("更新前：" + asrs.getStamp());
        System.out.println("更新前：" + asrs.getReference());

        //更新
        if (asrs.compareAndSet("预期值=初始值", "更新值", 1, asrs.getStamp() + 1)) {
            System.out.println("更新成功");
        } else {
            System.out.println("更新失败");
        }

        System.out.println("更新后：" + asrs.getStamp());
        System.out.println("更新后：" + asrs.getReference());
    }

在这里插入图片描述

3、原子更新数组

AtomicIntegerArray：原子更新整型数组里的元素

主要方法

	//返回数组的长度
    public final int length() {
        return array.length;
    }

	//获取索引位置i处的当前值。
    public final int get(int i) {
        return getRaw(checkedByteOffset(i));
    }

	//将索引位置i处的元素设置为给定值。
    public final void set(int i, int newValue) {
        unsafe.putIntVolatile(array, checkedByteOffset(i), newValue);
    }

	//原子地将索引位置i处的元素设置为给定值，并返回旧值
    public final int getAndSet(int i, int newValue) {
        return unsafe.getAndSetInt(array, checkedByteOffset(i), newValue);
    }

	//比较当前值=预期值，则原子地将索引位置i处的元素设置为给定的更新值。
    public final boolean compareAndSet(int i, int expect, int update) {
        return compareAndSetRaw(checkedByteOffset(i), expect, update);
    }

	//索引i处的元素按原子级递增1。返回更新前的值
    public final int getAndIncrement(int i) {
        return getAndAdd(i, 1);
    }

	//索引i处的元素按原子级递减1。返回更新前的值
    public final int getAndDecrement(int i) {
        return getAndAdd(i, -1);
    }
	
	//索引i处的元素按原子方式与给定值相加。返回更新前的值
    public final int getAndAdd(int i, int delta) {
        return unsafe.getAndAddInt(array, checkedByteOffset(i), delta);
    }

	//索引i处的元素按原子级递增1。返回更新后的值
    public final int incrementAndGet(int i) {
        return getAndAdd(i, 1) + 1;
    }

	//索引i处的元素按原子级递减1。返回更新后的值
    public final int decrementAndGet(int i) {
        return getAndAdd(i, -1) - 1;
    }

	//索引i处的元素按原子方式与给定值相加。返回更新后的值
    public final int addAndGet(int i, int delta) {
        return getAndAdd(i, delta) + delta;
    }

    private static void demo06() {
        int[] is = {1, 2, 3, 4, 5};
        AtomicIntegerArray aia = new AtomicIntegerArray(is);
        
        System.out.println(aia);
        System.out.println(aia.getAndAdd(1, 10));
        System.out.println(aia);
    }

在这里插入图片描述

AtomicLongArray：原子更新长整型数组里的元素

AtomicReferenceArray：原子更新引用类型数组里的元素

4、原子更新字段类型

AtomicIntegerFieldUpdater：原子更新整型字段类型

	//获取此更新程序管理的给定对象字段中的当前值
	public abstract int get(T obj);
	
	//如果当前值==预期值，则自动将此更新程序管理的给定对象的字段设置为给定的更新值
	public abstract boolean compareAndSet(T obj, int expect, int update);
	
	//原子地将此更新程序管理的给定对象的字段设置为给定值，并返回旧值
	public int getAndSet(T obj, int newValue);

	//此更新程序管理的给定对象的字段的当前值以原子方式递增1，并返回旧值
	public int getAndIncrement(T obj);

	//此更新程序管理的给定对象的字段的当前值以原子方式递减1，并返回旧值
	public int getAndDecrement(T obj);

	//以原子方式将给定值添加到此更新程序管理的给定对象的字段的当前值，并返回旧值
	public int getAndAdd(T obj, int delta)

	//此更新程序管理的给定对象的字段的当前值以原子方式递增1，并返回新值
	public int incrementAndGet(T obj);

	//此更新程序管理的给定对象的字段的当前值以原子方式递减1，并返回新值
	public int decrementAndGet(T obj);

	//以原子方式将给定值添加到此更新程序管理的给定对象的字段的当前值，并返回新值
	public int addAndGet(T obj, int delta)

    private static void demo07() {
        AtomicDemo demo = new AtomicDemo();
        AtomicIntegerFieldUpdater<AtomicDemo> aifu = AtomicIntegerFieldUpdater.newUpdater(AtomicDemo.class, "age");

        System.out.println(demo.age);
        System.out.println(aifu.get(demo));
        
        System.out.println(aifu.getAndIncrement(demo));
        System.out.println(demo.age);
        System.out.println(aifu.get(demo));
    }

在这里插入图片描述

AtomicLongFieldUpdater：原子更新长整型字段类型

AtomicReferenceFieldUpdater：原子更新引用字段类型

yzm4399
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11并发编程关于原子操作atomic的代码示例
08-26
今天小编就为大家分享一篇关于C++11并发编程关于原子操作atomic的代码示例，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
2万字Java并发编程面试题合集（含答案，建议收藏）
08-10
2万字Java并发编程面试题合集（含答案，建议收藏） 具体如下 1、在 java 中守护线程和本地线程区别？2、线程与进程的区别？3、什么是多线程中的上下文切换？4、死锁与活锁的区别，死锁与饥饿的区别？5、Java 中用到...
【Java原理系列】 AtomicInteger原理用法源码详解
wang2leee的博客
09-10 2687
`AtomicInteger` 的原理基于 CAS（Compare-And-Swap）操作。它内部使用了 `Unsafe` 类或者其他底层的原子操作机制来实现线程安全的操作。
JAVA学习-AtomicInteger
javaYanKang的博客
10-16 3917
本文主要介绍在java实际开发过程中遇到的AtomicInteger类使用，希望可以给一些小伙伴带来帮助。AtomicInteger类是具有原子性的对于Integer进行操作工具类。它通过Unsafe保证了原子性，提供了很多对值进行比较和交换的方法，参考CAS原理。后续本文会补充上述各方法的样例代码及使用场景，尽可能的通过该类的底层实现原理更深入的理解它，同时可以学习多线程并发场景下的一些相关知识。
Java使用AtomicInteger来实现原子性自增
test253506088的博客
07-08 9203
最近工作比较忙，没啥时间写笔记，丢一个老笔记上来吧。 先放出工具类代码： package com.example.demo; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; /** * 使用AtomicI
Java Integer原子操作——AtomicInteger
初心不改
07-14 1702
1.AtomicInteger类是系统底层保护的int类型，通过对int类型的数据进行封装，提供执行方法的控制进行值的原子操作，但AtomicInteger ≠ Integer。2.AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减。从JAVA 1.5开始，AtomicInteger 属于java.util.concurrent.atomic 包下的一个类。能够帮助你们解决问题是博主的荣幸，你们的支持是我创作的最大动力！
【Java 基础篇】Java线程：volatile关键字与原子操作详解
繁依Fanyi的博客
09-20 560
volatile关键字和原子操作是多线程编程中的重要概念，它们用于确保线程之间的可见性和数据一致性。volatile关键字用于声明一个变量是"易失性"的，确保对该变量的修改对其他线程是可见的。原子操作则提供了一系列不可分割的操作，保证了操作的原子性。合理地使用volatile关键字和原子操作可以提高多线程程序的性能和可靠性，但需要根据具体情况选择合适的方式。同时，也需要注意volatile关键字并不能替代锁机制，它们各有各的应用场景。在多线程编程中，保持谨慎和小心是非常重要的。希望本文能帮助您更好地理解。
java 并发 可见性_【并发】java并发之可见性与原子性
weixin_28832121的博客
02-24 117
一、定义1.可见性在多核处理器中，如果多个线程对一个变量(假设)进行操作，但是这多个线程有可能被分配到多个处理器中运行，那么编译器会对代码进行优化，当线程要处理该变量时，多个处理器会将变量从主存复制一份分别存储在自己的片上存储器中，等到进行完操作后，再赋值回主存。(这样做的好处是提高了运行的速度，因为在处理过程中多个处理器减少了同主存通信的次数)；同样在单核处理器中这样由于“备份”造成的问题同样存...
实战Java高并发程序设计-07原子操作
jiuxiao199132的博客
07-14 341
悲观与乐观 对于并发而言，锁是一种悲观策略。总是假设每一次临界区操作都会产生冲突，因此，必须每次操作都小心翼翼。如果有多个线程访问临界区资源，就牺牲性能让线程进行等待，使得线程阻塞。而无锁是一种乐观的策略，它会假设对资源的访问时没有冲突的，不需要等待，所有线程都可用不停顿的执行。那么在遇到冲突的情况下采用一种叫做比较交换技术（CAS Compare And Swap）来鉴别线程冲突，一旦检查到冲
Java原子操作AtomicInteger的用法
04-21 7019
原文：http://www.jianshu.com/p/509aca840f6d 前言: JDK1.5之后的java.util.concurrent.atomic包里，多了一批原子处理类。AtomicBoolean、AtomicInteger、AtomicLong、AtomicReference。主要用于在高并发环境下的高效程序处理,来帮助我们简化同步处理. AtomicInte
Java的Atomic原子类
飞鱼的博客
05-26 1106
Java SDK 并发包里提供了丰富的原子类，我们可以将其分为五个类别，这五个类别提供的方法基本上是相似的，并且每个类别都有若干原子类。
java编发编程：JUC综合讲解
08-09
原子操作是不可再分割的基本操作，JUC 提供了一系列原子操作类，如 AtomicInteger、AtomicLong 等。 4. 同步器（Synchronizers）：JUC 中的同步器主要通过 AQS（AbstractQueuedSynchronizer）提供支持。
并发编程笔记20190526.docx
07-01
5、原子操作CAS (compare atomic swap) 32 三、显式锁和AQS 34 1、AQS定义两种资源共享方式： 34 2、深入源码 37 3、了解Condition的实现 42 4、 锁的可重入 44 第三章 并发容器ConcurrentHashMap 46 一、JDK1.7中...
java int 自增_Java中对AtomicInteger和int值在多线程下递增操作的测试
weixin_39572442的博客
02-13 807
Java针对多线程下的数值安全计数器设计了一些类,这些类叫做原子类,其中一部分如下:java.util.concurrent.atomic.AtomicBoolean;java.util.concurrent.atomic.AtomicInteger;java.util.concurrent.atomic.AtomicLong;java.util.concurrent.atomic.AtomicR...
java 多线程 递增_Java的多线程编程模型5--从AtomicInteger开始(自增长实现)
weixin_31517893的博客
02-16 354
AtomicInteger，一个提供原子操作的Integer的类。在Java语言中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的加减操作接口。来看AtomicInteger提供的接口。//获取当前的值public final int get()//取当前的值，并设置新的值public final ...
Java AtomicInteger 学习以及理解
weixin_44131922的博客
08-25 626
然而，这个类确实扩展了{@code Number}，允许处理基于数值的类的工具和实用程序进行统一访问。这个类在我看来实现了一个数字自增和自减的一个类，由于有初始的创建值，因此如果不做其他处理额外处理的话，每次重新启动那么这个初始值都会被初始化，重新递增。经过一些资料的查询和确认，该类更多的是用在多线程场景，或校验保证操作的原子性，原子性，即唯一一个，保证只有一个可操作对象。否则不予赋值，返回是否一致的 布尔值。在实际使用时可能有多个这个样的计数器，例如JDK 内部对线程的生成名做区别则如下使用。
测试AtomicInteger与普通int值在多线程下的递增操作
weixin_34117211的博客
06-10 269
日期: 2014年6月10日作者: 铁锚Java针对多线程下的数值安全计数器设计了一些类,这些类叫做原子类,其中一部分如下:java.util.concurrent.atomic.AtomicBoolean; java.util.concurrent.atomic.AtomicInteger; java.util.concurrent.atomic.AtomicLong; java.util....
那些Java中原子类的使用
机智的爆爆哥
10-28 794
对java原子类的总结，方便以后回看
Java毕业设计-基于SSM框架的大学生社团管理系统带lw(源码+演示视频+说明).rar
最新发布
05-09
Java毕业设计-基于SSM框架的大学生社团管理系统带lw(源码+演示视频+说明).rar 【项目技术】 开发语言：Java 框架：ssm+vue 架构：B/S 数据库：mysql 【演示视频-编号：438】 https://pan.quark.cn/s/b3a97032fae7 【实现功能】 实现了社长管理，社团信息管理，社团分类管理，社团加入信息管理，社团成员登记管理，活动信息管理等功能。
狂神说java-juc并发编程
09-23
其中，java.util.concurrent.atomic包提供了一些原子性操作的类，可以保证线程安全地对变量进行操作；java.util.concurrent.locks包提供了各种锁，如ReentrantLock和ReadWriteLock，用于实现更加复杂的线程同步控制...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值