今天终于彻底懂了原子类！！舒服

最新推荐文章于 2024-08-07 11:15:21 发布
最新推荐文章于 2024-08-07 11:15:21 发布
阅读量1.2k 收藏 24
点赞数 42
分类专栏： 深入理解高并发和多线程 文章标签： java jvm 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/likang_1167/article/details/140389526
版权

最近,小强公司业务最近想要做个服务监控预警的功能，其实就是统计节点的实时QPS，实时线程数，当QPS或者线程数大于一定值会报错，小强果断上了Long 类型，结果。。。。发现实际的值比统计的值大。。
导致一个很严重的线上事故，被祭天了。。。。
image.png
小强下来也很不解，因为在测试环境测试过，是没问题的。。。。。。 他自己模拟了一下，发现果真有问题

public class CasDemo {
    public static Long count = 0L;

    public static void main(String[] args) throws InterruptedException {

        ExecutorService executorService = Executors.newCachedThreadPool();


        for (int i = 0; i <= 1000; i++) {
            executorService.execute(() -> {
                count = count + 1 ;
            });
        }

        Thread.sleep(1000);
        System.out.println(count);
        executorService.shutdown();
    }
}

按正常是应该1000，当时只有90
image.png

小强气的跟我讲，那我给他去说下这种情况到底该怎么解决！
image.png

现在看下问题到底出在哪！！！ 带给大家一个新名字：原子操作

1.什么是原子操作

想必很多同学都用过事务，原子性是事务中的一大特性，表示一个事务包含多个操作，要么全部成功，要么全部失败。
实现原子操作可以使用锁，锁机制可以满足基本的需求了，但是synchronized关键字是基于阻塞的锁机制，对于锁的处理不够灵活。

2.如何实现原子操作

原子操作的基本顺序：
如何这个地址上的值和期望的值相等，则给于赋予新的值，否则不做任何事，但是要返回原值是多少。

是不是感觉很神奇，其实小强之前遇到的问题其实就是每个线程从主内存获取副本变量，并且自增，再次回写到主变量，那么假如有两个线程，同时拿到，并且同时增加1，同时写回主内存就会有相互覆盖的问题，所以最后增加的值肯定是必实际量要小。

3.AtomicInteger/AtomicLong

  • int addAndGet（int delta）：将输入的数值与原子类中的值以原子性的方式相加，并返回结果。
  • boolean compareAndSet（int expect ，int update）：如果输入的数值等于预 期值，则以原子方式将该值设置为输入的值，如果设置成功则返回true，否则返回false。
  • int getAndIncrement()：以原子方式将当前值加 1，注意，这里返回的是自增前的值。

1.解决监控并发的类

public class CasDemo {
    public static AtomicLong count = new AtomicLong(0L);

    public static void main(String[] args) throws InterruptedException {

        ExecutorService executorService = Executors.newCachedThreadPool();


        for (int i = 0; i < 1000; i++) {
            executorService.execute(() -> {
                count.getAndIncrement();
            });
        }

        Thread.sleep(1000);
        System.out.println(count);
        executorService.shutdown();
    }
}

image.png

有没有想过上面的结果为什么是1000？？？ 那让我们来分析一下！！！

关键方法分析：

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

    public final long getAndAddLong(Object var1, long var2, long var4) {
        long var6;
        do {
            var6 = this.getLongVolatile(var1, var2);
        } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));

        return var6;
    }

getLongVolatile()和compareAndSwapLong() 都是原子操作，其实上面的是一个循环不断CAS的过程。循环结果如下：
image.png

其实原子类比我们普通的累加多个一个步骤就是在每次真正更新内存之前去比较内存中的值是否和当初读取的值一样。

你肯定以为到这就我们就结束了，那你大错特错了，里面有好多坑你知道么？
接着继续往下看！！！里面到底有啥坑
image.png

2.CAS自旋锁的三大问题

1.ABA问题

因为 CAS 需要在操作值的时候， 检查值有没有发生变化， 如果没有发生变化 则更新，但是如果一个值原来是 A，变成了 B，又变成了 A，那么使用 CAS 进行 检查时会发现它的值没有发生变化，但是实际上却变化了，这样就会导致ABA的问题
如何避免CAS问题，就是就是使用版本号，在变量前面追加上版本号，每次更新的时候把当前的版本加1。

2.CPU消耗大

自旋CAS如果长时间不成功，对CPU会有非常大的执行的开销，因此比较适合并发量不大的场景。

3.只能保证单共享变量的原子操作

当对一个共享变量执行操作时， 我们可以使用循环 CAS 的方式来保证原子操 作， 但是对多个共享变量操作时， 循环 CAS 就无法保证操作的原子性， 这个时候 就可以用锁。
还有一个取巧的办法， 就是把多个共享变量合并成一个共享变量来操作。比 如，有两个共享变量 i ＝2，j=a，合并一下 ij=2a，然后用 CAS 来操作 ij。从 Java 1.5 开始， JDK 提供了 AtomicReference 类来保证引用对象之间的原子性，就可以把 多个变量放在一个对象里来进行 CAS 操作。

为了解决这些问题，在听我多比比几句，接着往下走起！！！哈哈哈哈哈哈

4.并发相关类

1.引用类型更新

1.AtomicReference

原子更新引用类型，可以原子性的更新多个变量，但是会有ABA问题。

2.AtomicStampedReference

利用版本戳的形式记录每次改变以后的版本号，这样的话就不会存在ABA问题。

2.类字段原子更新

 前面我们所讲的几个原子更新引用类型如：AtomicReference，用于整个对象的更新。但不是每次都必须更新整个对象，有可能我们只需对对象中的某个字段进行原子性修改时，那么就需要使用原子更新字段类
  1. AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。
  2. AtomicLongFieldUpdater：原子更新长整型字段的更新器。
  3. AtomicStampedReference：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于原子的更数据

这几个类，我们重点看下AtomicIntegerFieldUpdater

  1. 字段必须是 volatile 类型的
  2. 字段不能用static修饰
  3. 字段不能用final修饰
  4. AtomicIntegerFieldUpdate 和 AtomicLongFieldUpdate 只能修改 int/long 类型的字段，不能修改包装类型。如果要修改包装类型就需要使用 AtomicReferenceFieldUpdate
  5. 调用者能够直接操作对象字段。但是对于父类的字段，子类是不能直接操作的，尽管子类可以访问父类的字段。

举个栗子 ！！！

public class AtomicIntegerFieldDemo {

    private static AtomicIntegerFieldUpdater<User> atomicIntegerFieldUpdater = AtomicIntegerFieldUpdater.newUpdater(User.class, "id");

    public static void main(String[] args) {
        User user = new User(1, "xiaoqiang");

        System.out.println("调用atom.addAndGet(user, 50)方法返回值为：" + atomicIntegerFieldUpdater.addAndGet(user, 50));
        System.out.println(user);
    }
}

class User {
     volatile int id;

     String name;

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

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

别急别急！还有最后一个点，如果你在高并发的情况下，AtomicLong增加的值的时候，会出现N个线程同时进行自旋操作，会出现大量失败不断自旋的情况，此时AtomicLong 的自旋会成为瓶颈。来来来 ！！！加个餐

5.LongAdder

1707044540212.png

1.架构总览

LongAdder 在高并发的场景下会比AtomicLong具有更好的并发性能
LongAdder的基本思路就是分散热点，将value值分散到一个数组中，不同的线程会放到不同的槽中，各个线程对自己的槽中的值进行CAS操作，这样其实就就相当于热点分散了，冲突的概率会变小，这个其实就是和ConcurrentHashMap 中的“分段锁”其实就是类似的思路。

image.png

代码示例

public static void main(String[] args) throws Exception {
    long start1 = System.currentTimeMillis();
    testLongAdder();
    System.out.println("LongAdder 耗时：" + (System.currentTimeMillis() - start1) + "ms");
    long start2 = System.currentTimeMillis();
    testAtomicLong();
    System.out.println("AtomicLong 耗时：" + (System.currentTimeMillis() - start2) + "ms");
    System.out.println("----------------------------------------");
}

static void testAtomicLong() throws Exception{
AtomicLong atomicLong = new AtomicLong();
List<Thread> list = new ArrayList();
for (int i = 0; i < 9999; i++) {
    list.add(new Thread(() -> {
        for(int j=0;j<100000;j++){
            atomicLong.incrementAndGet();
        }
    }));
}

for (Thread thread : list) {
    thread.start();
}
for (Thread thread : list) {
    thread.join();
}

System.out.println("AtomicLong value is : " + atomicLong.get());
}

static void testLongAdder() throws Exception{
    LongAdder longAdder = new LongAdder();
    List<Thread> list = new ArrayList();
    for (int i = 0; i < 9999; i++) {
        list.add(new Thread(() -> {
            for(int j=0;j<100000;j++){
                longAdder.increment();
            }
        }));
    }

    for (Thread thread : list) {
        thread.start();
    }
    for (Thread thread : list) {
        thread.join();
    }

    System.out.println("LongAdder value is : " + longAdder.longValue());
}

2.关键方法

1.LongAdder.increment()

public void increment() {
    add(1L);
}

   public void add(long x) {
        Cell[] as; long b, v; int m; Cell a;
    	//判断base变量是否更新成功
        if ((as = cells) != null || !casBase(b = base, b + x)) {
            boolean uncontended = true;
            if (as == null || (m = as.length - 1) < 0 ||
                //取对应的槽
                (a = as[getProbe() & m]) == null ||
                //给对应的槽累加值
                !(uncontended = a.cas(v = a.value, v + x)))
                longAccumulate(x, null, uncontended);
        }
    }

2.LongAdder.sum()

    public long sum() {
        Cell[] as = cells; Cell a;
        long sum = base;
        if (as != null) {
            //base的值加上cell的值
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

LongAdder 对最终结果的求和，并没有使用全局锁，所以返回的值并不是绝对准确的，因为还会有其他线程进行计数累加，所以只能得到近似值，这也就是 **LongAdder **并不能完全替代 **LongAtomic **的原因之一。

至此，我们的CAS先告一短路，掌握到这个程度基本上在工作中没问题了。

image.png

程序员蓝海
关注
  • 42
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C#进阶3-4】C#设计模式
CSDN博客专家，Unity3D高级软件工程师，《Unity 3D从入门到实战》作者。
05-19 6611
一、目录 文章目录一、目录二、设计原则三、创建型模式3.1、单例模式（Singleton Pattern）3.2、工厂方法模式（Factory Pattern）3.3、抽象工厂模式（Abstract Pattern）3.4、建造者模式（Builder Pattern）3.5、原型模式（Prototype Pattern）四、结构性模式4.1、适配器模式（Adapter Pattern）4.2、桥接模式（Bridge Pattern）4.3、装饰者模式（Decorator Pattern）4.4、组合模式（C
★寒门再难出贵子？太现实了！【下】
全栈空间
01-05 1996
小东和原子的故事 　　小东是个男孩，家境不必周周差，也许还强点，但是这是唯一一个可以留在银行，但没有留下的孩子，还是因为家境。这个孩子很幽默，不讨厌，据说已经家里给协调好了关系，可以留下，最终他的老干部爷爷，没有同意他留在银行。毕业后拿着红头文件去了南京某指挥学院，深造了一年，取得了研究生学历，然后分回本地，去做了军人。单位是后勤部，很舒服的单位，很惬意，分了一套房子，找了个军官做老婆。
终于有人把“人工智能”讲明白是怎么回事了！
影落离风
10-09 3464
我们正站在变革的边缘，而这次变革将和人类的出现一般意义重大 – Vernor Vinge。如果你站在这里，你会是什么感觉？ 看上去非常刺激吧？但是你要记住，当你真的站在时间的图表中的时候，你是看不到曲线的右边的，因为你是看不到未来的。所以你真实的感觉大概是这样的： 稀松平常。 ------------------------------- 遥远的未来——就在眼前 想象一下坐...
JDK源码——源码学习总结与分析
庄小焱
11-23 1882
如何阅读源码，是每个程序员需要面临的一项挑战，为什么需要阅读源码?从实用性的角度来看，主要有三个目的： 解决手头的新问题或者新需求;真正理解一部分理论的落地实现， 应对面试。作为一名java的开发者，需要对JDK源码有一定的了解和学习，同时也是个人能力的体现，也是在面试中给自己的加分项目。因此个人分享JDK源码的学习方法。
这一年，这些书：2022年读书笔记
Heartsuit的博客
12-31 3万+
Note: 以下 `markdown` 格式文本由 `json2md` 自动转换生成，可参考[JSON转Markdown：我把阅读数据从MongoDB中导出转换为.md了](https://blog.csdn.net/u013810234/article/details/113360229)了解具体的转换过程。2022年读书笔记
读不完《程序员修炼之道》，至少可以读完这70条
howard2005的专栏
06-04 1038
当我在图书馆看到这本《程序员修炼之道》的时候，直觉告诉我应该看看这本书，或许对我的成长有帮助。读完之后更加肯定了自己的直觉是对的。当时我虽然没有实际项目的开发经验，不能一时领悟其意，但我明白，这本书中总结的原则和方法对我来说是极为宝贵的，于是买了一本放在床头。
微服务架构下静态数据通用缓存机制
CSDN业界要闻
01-28 186
戳蓝字“CSDN云计算”关注我们哦！作者：Ala6来源：Docker在分布式系统中，特别是最近很火的微服务架构下，有没有或者能不能总结出一个业务静态数据的通用缓存处理机制...
中国自由软件推广先锋的自述，心潮澎湃的一往无前，一定要看！作者：洪峰
热门推荐
Shane from Spads
05-18 4万+
一定要看，原文地址是： http://www.cppblog.com/toMyself/archive/2010/08/29/125217.html 本文内容经过了我（Shane Loo Li）少许修改，主要是更新了目录。 自由软件：新的游戏规则 洪峰   内篇之一：“一、百、万”工程    1. 牛犊涉世之初    2. 迷雾中的引路人    3. 蹉跎岁月
深入了解Java atomic原子类的使用方法和原理
08-25
Java Atomic原子类的使用方法和原理 Java Atomic原子类是Java中的一种多线程安全机制，用于在多线程环境中保证变量的原子性操作。Atomic原子类的出现解决了多线程环境下变量操作的安全问题，使得开发者可以更方便地...
Java原子变量类原理及实例解析
08-25
Java原子变量类原理及实例解析 一、原子变量类简介 Java中的原子变量类是为了解决多线程环境下数据的一致性问题而设计的。它可以确保多线程环境下数据的原子性、可见性和有序性。原子变量类的主要特点是它可以在多...
Java原子变量类常见问题解决
08-19
Java中的原子变量类是Java并发编程中非常重要的工具，它们提供了高效的并发操作，尤其是在多线程环境下处理共享变量时。这些类包括`AtomicInteger`, `AtomicLong`, `AtomicBoolean`等，它们通过使用无锁算法（CAS，...
Java concurrency之AtomicLong原子类_动力节点Java学院整理
08-30
Java concurrency之AtomicLong原子类 AtomicLong是Java concurrency中的一种原子类，用于对长整形进行原子操作。在32位操作系统中，64位的long和double变量由于会被JVM当作两个分离的32位来进行操作，所以不具有...
Java concurrency之AtomicLongArray原子类_动力节点Java学院整理
08-30
Java并发编程中的`AtomicLongArray`是`java.util.concurrent.atomic`包中的一种原子类，它提供了一种在多线程环境下安全地操作长整型数组的方式。`AtomicLongArray`类实现了对数组元素的原子性读取、更新和比较交换...
【Spring Boot】高效配置管理: 易用性与灵活性并重
weixin_68020300的博客
08-07 1257
本文探讨了Spring Boot中多样化的配置读取方法及其应用场景，强调了配置管理的重要性，并展示了Spring Boot如何通过灵活多变的配置选项简化这一过程。此外，文章还展望了配置管理领域未来的技术趋势和发展方向。对于任何希望深入了解Spring Boot配置管理的开发者来说，这是一篇不容错过的好文。
C++ - 函数重载
jiaowenjie的专栏
08-06 330
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 247
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
Spring事务
最新发布
c1tenj2的博客
08-07 436
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
原子类 volatile
09-29
原子类是Java中的一个小工具包，位于java.util.concurrent.atomic包中。它提供了一种线程安全编程的方式，支持在单个变量上解除锁。原子变量类相当于一种泛化的volatile变量，能够支持原子的和有条件的读-改-写操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值