原子操作类

程序员爱中国

已于 2024-07-26 13:04:37 修改

阅读量787

点赞数 9

CC 4.0 BY-SA版权

分类专栏： java # juc并发编程文章标签： java 并发编程 LongAdder 原子操作类

于 2024-07-25 17:21:33 首次发布

本文链接：https://blog.csdn.net/pang_ping/article/details/140667383

java 同时被 2 个专栏收录

107 篇文章

订阅专栏

juc并发编程

12 篇文章

订阅专栏

在这里插入图片描述

基本类型原子类

AtomicInteger
AtomicBoolean
AtomicLong

问题案例：为什么结果是不准呢，因为里面的50个线程还没有跑完，main线程去拿结果，就会导致没有计算完拿到了错误结果
在这里插入图片描述
要等前面50个线程跑完，让main线程sleep一段时间也可以，但是不太好，怎么解决呢？

countDownLatch，50个线程，等到50个线程都跑完，后面的线程拿到最终值

数组类型原子类

AtomicIntegerArray
AtomicLongArray
AtomicReferenceArray

案例演示：数组根据下标获取数值
在这里插入图片描述

引用类型原子类

AtomicReference
AtomicStampedReference（利用版本号，解决ABA问题，能够知道修改了几次）
AtomicMarkableReference（将状态戳简化为true/false，解决是否修改过）

案例演示：同时间不同线程拿到的都是false初始化值，但是a线程执行完之后，发生了改变，b线程再去修改时，发现值被使用过，再次修改失败
在这里插入图片描述

对象的属性修改原子类

AtomicLongFieldUpdater
AtomicIntegerFieldUpdater
AtomicReferenceFieldUpdater

作用：以一种线程安全的方式操作非线程安全对象内的某些字段

不用原子操作类以前：效果虽然能实现，但是加了synchronized
在这里插入图片描述

现在不加锁，针对引用类的字段进行原子性操作：效果也一致
在这里插入图片描述

上面是针对integer，那么引用类中的字段呢？来，让我们接着奏乐接着舞

AtomicReferenceFieldUpdater：基于反射的实用程序，可以对指定类的指定volatile引用字段进行原子更新。

需求：多线程并发调用一个类的初始化方法，如果未被初始化，将执行初始化工作，要求只能被初始化一次，只有一个线程操作成功

案例实现如下：
在这里插入图片描述

原子操作增强类

DoubleAccumulator
DoubleAdder
LongAccumulator
LongAdder

这几个是java8出来的增强类，前面十二个是java5的原子操作类
在这里插入图片描述
按照以上图片红框内容，我们来实现一个热点商品点赞数，点赞累加统计，要求吞吐量极高，不要求实时精准的（98%）需求（因为正在统计时，也在实时增加点赞数）

单线程简单使用：
在这里插入图片描述
以上案例可以总结出：LongAdder支持简单的加法计算，计算初始量从0开始，而LongAccumulator支持自定义计算公式，且初始值也可以自定义

多线程案例：50个线程，每个线程100w次，统计总点赞数

内部类：

class ClickNumber{
    int number = 0;
    public synchronized void clickSynchronized(){
        number++;
    }

    AtomicLong atomicLong = new AtomicLong(0);
    public void clickAtomicLong(){
        atomicLong.incrementAndGet();
    }

    LongAdder longAdder = new LongAdder();
    public void clickLongAdder(){
        longAdder.increment();
    }

    LongAccumulator longAccumulator = new LongAccumulator((x,y)->x+y,0);
    public void clickLongAccumulator(){
        longAccumulator.accumulate(1);
    }
}

实现类：

public static final int _1w = 10000;
    public static final int threadNumber = 50;

    public static void main(String[] args) throws InterruptedException {
        ClickNumber clickNumber = new ClickNumber();
        long startTime;
        long endTime;
        final CountDownLatch countDownLatch1 = new CountDownLatch(threadNumber);
        final CountDownLatch countDownLatch2 = new CountDownLatch(threadNumber);
        final CountDownLatch countDownLatch3 = new CountDownLatch(threadNumber);
        final CountDownLatch countDownLatch4 = new CountDownLatch(threadNumber);

        startTime = System.currentTimeMillis();
        for (int i = 0; i < threadNumber; i++) {
            new Thread(()->{
                try {
                    for (int j = 1; j <= 100 * _1w; j++) {
                        clickNumber.clickSynchronized();
                    }
                } finally {
                    countDownLatch1.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch1.await();
        endTime = System.currentTimeMillis();
        System.out.println("耗时："+(endTime-startTime)+"毫秒 \t clickSynchronized："+clickNumber.number);


        startTime = System.currentTimeMillis();
        for (int i = 0; i < threadNumber; i++) {
            new Thread(()->{
                try {
                    for (int j = 1; j <= 100 * _1w; j++) {
                        clickNumber.clickAtomicLong();
                    }
                } finally {
                    countDownLatch2.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch2.await();
        endTime = System.currentTimeMillis();
        System.out.println("耗时："+(endTime-startTime)+"毫秒 \t clickAtomicLong："+clickNumber.atomicLong.get());

        startTime = System.currentTimeMillis();
        for (int i = 0; i < threadNumber; i++) {
            new Thread(()->{
                try {
                    for (int j = 1; j <= 100 * _1w; j++) {
                        clickNumber.clickLongAdder();
                    }
                } finally {
                    countDownLatch3.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch3.await();
        endTime = System.currentTimeMillis();
        System.out.println("耗时："+(endTime-startTime)+"毫秒 \t clickLongAdder："+clickNumber.longAdder.sum());

        startTime = System.currentTimeMillis();
        for (int i = 0; i < threadNumber; i++) {
            new Thread(()->{
                try {
                    for (int j = 1; j <= 100 * _1w; j++) {
                        clickNumber.clickLongAccumulator();
                    }
                } finally {
                    countDownLatch4.countDown();
                }
            },String.valueOf(i)).start();
        }
        countDownLatch4.await();
        endTime = System.currentTimeMillis();
        System.out.println("耗时："+(endTime-startTime)+"毫秒 \t clickLongAccumulator："+clickNumber.longAccumulator.get());

    }

效果图：
在这里插入图片描述
从效果图中看，LongAdder高并发大数据量下性能比AtomicLong好10倍

那么为什么LongAdder能那么快呢？

LongAdder 高性能原理说明

AtomicLong是通过CAS自旋保证原子性，高并发大数量的情况下，也是一个个执行，所以性能不佳

LongAdder底层有base跟cell理念设计，在低并发情况下，跟AtomicLong性质一样，通过本身base的CAS自旋处理，但是高并发情况下，base一个肯定忙不过来，就启用cell扩容，开启多个窗口cell[0]、cell[1]、cell[…]，利用base+cell达到分散热点的作用，如果要获取真正的long值，结果就是base+cell数组

而以上LongAdder设计思想是通过Striped64这个类落地实现的，LongAdder是Striped64的子类
在这里插入图片描述
LongAdder性能那么好主要原因是Striped64，这是Striped64类的一些变量或参数定义，其中最重要的就是NCPU、cells、base、cellsBusy