关于CAS与Atomic原子操作

秋天的一亩三分地

已于 2022-11-12 15:45:32 修改

阅读量232

点赞数

分类专栏：并发编程专栏文章标签： jvm java 开发语言

于 2022-11-10 23:12:38 首次发布

本文链接：https://blog.csdn.net/weixin_45925485/article/details/127798002

版权

并发编程专栏专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、CAS

1、CAS介绍

CAS（Compare And Swap，比较并交换），通常指的是这样一种原子操作：针对一个变量，首先比较它的内存值与某个期望值是否相同，如果相同，就给它赋一个新值。
在这里插入图片描述
CAS 的逻辑用伪代码描述如下：

if (value == expectedValue) {
	value = newValue;
}

以上伪代码描述了一个由比较和赋值两阶段组成的复合操作，CAS 可以看作是它们合并后的整体——一个不可分割的原子操作，并且其原子性是直接在硬件层面得到保障的。

CAS可以看做是乐观锁（对比数据库的悲观、乐观锁）的一种实现方式，Java原子类中的递增操作就通过CAS自旋实现的。

CAS是一种无锁算法，在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。

2、CAS应用

在 Java 中，CAS 操作是由 Unsafe 类提供支持的，该类定义了三种针对不同类型变量的 CAS 操作：

public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);

以上均为native方法，由JVM提供具体实现，这意味着不同的JVM对它们的实现可能会略有不同。

以 compareAndSwapInt 为例，Unsafe 的 compareAndSwapInt 方法接收 4 个参数，分别是：对象实例、内存偏移量、字段期望值、字段新值。该方法会针对指定对象实例中的相应偏移量的字段执行 CAS 操作。

内存偏移量：从第几个下标开始读值，下方测试里entity需要读取x的值，而创建一个对象，对象头的Mark Word占8个字节，类型指针占4个字节，因此偏移量为12，即x要从下标12开始读取，由于x的数据类型为int，占4个字节，因此entity对象大小为16个字节。
假设entity内部还有个y值，即：
class Entity {
int y；
int x;
}
此时若要读取x的值，则偏移量为 Mark Word8字节+类型指针4字节+int类型的y4字节 =16。

public class CASTest {
    public static void main(String[] args) {
        Entity entity = new Entity();

        Unsafe unsafe = UnsafeFactory.getUnsafe();

        long offset = UnsafeFactory.getFieldOffset(unsafe, Entity.class, "x");

        boolean successful;

        //4个参数分别是：对象实例、字段的内存偏移量、字段期望值、字段心智
        successful = unsafe.compareAndSwapInt(entity, offset, 0, 3);
        System.out.println(successful + "\t" + entity.x);

        successful = unsafe.compareAndSwapInt(entity, offset, 3, 5);
        System.out.println(successful + "\t" + entity.x);

        successful = unsafe.compareAndSwapInt(entity, offset, 3, 8);
        System.out.println(successful + "\t" + entity.x);
    }
}

class Entity {
    int x;
}

public class UnsafeFactory {
    /**
     * 获取 Unsafe 对象
     *
     * @return
     */
    public static Unsafe getUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取字段的内存偏移量
     *
     * @param unsafe
     * @param clazz
     * @param fieldName
     * @return
     */
    public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName) {
        try {
            return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }
}

测试：针对 entity.x 的 3 次 CAS 操作，分别试图将它从 0 改成 3、从 3 改成 5、从 3 改成 8。
执行结果如下：

true	3
true	5
false	5

3、CAS源码分析

Hotspot 虚拟机对compareAndSwapInt 方法的实现如下：

#unsafe.cpp
UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
    UnsafeWrapper("Unsafe_CompareAndSwapInt");
    oop p = JNIHandles::resolve(obj);
    // 根据偏移量，计算value的地址
    jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
    // Atomic::cmpxchg(x, addr, e) cas逻辑 x:要交换的值 e:要比较的值
    //cas成功，返回期望值e，等于e,此方法返回true
    //cas失败，返回内存中的value值，不等于e，此方法返回false
    return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

核心逻辑在 Atomic::cmpxchg 方法中，但根据不同操作系统和不同CPU会有不同的实现。

以linux_64x的为例，查看 Atomic::cmpxchg 的实现：

#atomic_linux_x86.inline.hpp
inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest, jint compare_value) {
    //判断当前执行环境是否为多处理器环境
    int mp = os::is_MP();
    //LOCK_IF_MP(%4) 在多处理器环境下，为 cmpxchgl 指令添加 lock 前缀，以达到内存屏障的效果
    //cmpxchgl 指令是包含在 x86 架构及 IA‐64 架构中的一个原子条件指令，
    //它会首先比较 dest 指针指向的内存值是否和 compare_value 的值相等，
    //如果相等，则双向交换 dest 与 exchange_value，否则就单方面地将 dest 指向的内存值交给exchange_value。
    //这条指令完成了整个 CAS 操作，因此它也被称为 CAS 指令。
    __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
    : "=a" (exchange_value)
    : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
    : "cc", "memory");
    return exchange_value;
}

cmpxchgl的详细执行过程：
首先，输入是"r" (exchange_value), “a” (compare_value), “r” (dest), “r” (mp)，表示compare_value存入eax寄存器，而exchange_value、dest、mp的值存入任意的通用寄存器。嵌入式汇编规定把输出和输入寄存器按统一顺序编号，顺序是从输出寄存器序列从左到右从上到下以“%0”开始，分别记为%0、%1∙∙∙%9。也就是说，输出的eax是%0，输入的exchange_value、compare_value、dest、mp分别是%1、%2、%3、%4。
因此，cmpxchg %1,(%3)实际上表示cmpxchg exchange_value,(dest)需要注意的是cmpxchg有个隐含操作数eax，其实际过程是先比较eax的值(也就是compare_value)和dest地址所存的值是否相等，输出是"=a" (exchange_value)，表示把eax中存的值写入exchange_value变量中。
Atomic::cmpxchg这个函数最终返回值是exchange_value，也就是说，如果cmpxchgl执行时compare_value和dest指针指向内存值相等则会使得dest指针指向内存值变成exchange_value，最终eax存的compare_value赋值给了exchange_value变量，即函数最终返回的值是原先的compare_value。此时Unsafe_CompareAndSwapInt的返回值(jint)(Atomic::cmpxchg(x, addr, e)) == e就是true，表明CAS成功。如果cmpxchgl执行时compare_value和(dest)不等则会把当前dest指针指向内存的值写入eax，最终输出时赋值给exchange_value变量作为返回值，导致(jint)(Atomic::cmpxchg(x, addr, e)) == e得到false，表明CAS失败。

现代处理器指令集架构基本上都会提供 CAS 指令，例如 x86 和 IA-64 架构中的 cmpxchgl 指令和 comxchgq 指令，sparc 架构中的 cas 指令和 casx 指令。

不管是 Hotspot 中的 Atomic::cmpxchg 方法，还是 Java 中的 compareAndSwapInt 方法，它们本质上都是对相应平台的 CAS 指令的一层简单封装。CAS 指令作为一种硬件原语，有着天然的原子性，这也正是 CAS 的价值所在。

4、CAS缺陷

CAS 虽然高效地解决了原子操作，但是还是存在一些缺陷的，主要表现在三个方面：

自旋 CAS 长时间地不成功，则会给 CPU 带来非常大的开销
只能保证一个共享变量原子操作
ABA 问题

5、ABA问题及其解决方案

CAS算法实现一个重要前提需要取出内存中某时刻的数据，而在下时刻比较并替换，那么在这个时间差类会导致数据的变化。

ABA问题

当有多个线程对一个原子类进行操作的时候，某个线程在短时间内将原子类的值A修改为B，又马上将其修改为A，此时其他线程不感知，还是会修改成功。
在这里插入图片描述
测试：

public class ABATest {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(1);

        new Thread(() -> {
            int value = atomicInteger.get();
            System.out.println("Thread1 read value：" + value);

            //阻塞1s
            LockSupport.parkNanos(1000000000L);

            //Thread1通过CAS修改value值为3
            if (atomicInteger.compareAndSet(value, 3)) {
                System.out.println("Thread1 update from " + value + " to 3");
            } else {
                System.out.println("Thread1 update fail!");
            }
        }).start();

        new Thread(() -> {
            int value = atomicInteger.get();
            System.out.println("Thread2 read value：" + value);
            //Thread2通过CAS修改value值为2
            if (atomicInteger.compareAndSet(value, 2)) {
                System.out.println("Thread2 update from " + value + " to 2");
            }

            //do something
            value = atomicInteger.get();
            System.out.println("Thread2 read value：" + value);
            //Thread2通过CAS修改value值为1
            if (atomicInteger.compareAndSet(value, 1)) {
                System.out.println("Thread2 update form " + value + " to 1");
            }
        }, "Thread2").start();
    }
}

Thread1不清楚Thread2对value的操作，误以为value=1没有修改过

Thread1 read value：1
Thread2 read value：1
Thread2 update from 1 to 2
Thread2 read value：2
Thread2 update form 2 to 1
Thread1 update from 1 to 3

ABA问题的解决方案

数据库有个锁称为乐观锁，是一种基于数据版本实现数据同步的机制，每次修改一次数据，版本就会进行累加。

同样，Java也提供了相应的原子引用类AtomicStampedReference

public class AtomicStampedReference<V> {

    private static class Pair<T> {
        final T reference;
        final int stamp;
        private Pair(T reference, int stamp) {
            this.reference = reference;
            this.stamp = stamp;
        }
        static <T> Pair<T> of(T reference, int stamp) {
            return new Pair<T>(reference, stamp);
        }
    }

    private volatile Pair<V> pair;

reference即实际存储的变量，stamp是版本，每次修改可以通过+1保证版本唯一性。这样就可以保证每次修改后的版本也会往上递增。

public class AtomicStampedReferenceTest {
    public static void main(String[] args) {
        //定义AtomicStampedReference
        //Pair.reference值为1
        //Pair.stamp值为1
        AtomicStampedReference atomicStampedReference = new AtomicStampedReference(1, 1);

        new Thread(() -> {
            int[] stampHolder = new int[1];
            int value = (int) atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            System.out.println("Thread1 read value：" + value + "，stamp：" + stamp);

            //阻塞1s
            LockSupport.parkNanos(1000000000L);
            //Thread1通过CAS修改value值为3
            if (atomicStampedReference.compareAndSet(value, 3, stamp, stamp + 1)) {
                System.out.println("Thread1 update from " + value + " to 3");
            } else {
                System.out.println("Thread1 update fail!");
            }
        }, "Thread1").start();

        new Thread(() -> {
            int[] stampHolder = new int[1];
            int value = (int) atomicStampedReference.get(stampHolder);
            int stamp = stampHolder[0];
            System.out.println("Thread2 read value：" + value + "，stamp：" + stamp);
            //Thread2通过CAS修改value值为2
            if (atomicStampedReference.compareAndSet(value, 2, stamp, stamp + 1)) {
                System.out.println("Thread2 update from " + value + " to 2");

                //do something
                value = (int) atomicStampedReference.get(stampHolder);
                stamp = stampHolder[0];
                System.out.println("Thread2 read value：" + value + "，stamp：" + stamp);
                //Thread2通过CAS修改value值为1
                if (atomicStampedReference.compareAndSet(value, 1, stamp, stamp + 1)) {
                    System.out.println("Thread2 update from " + value + " to 1");
                }
            }
        }, "Thread2").start();
    }
}

Thread1并没有成功修改value

Thread1 read value：1，stamp：1
Thread2 read value：1，stamp：1
Thread2 update from 1 to 2
Thread2 read value：2，stamp：2
Thread2 update from 2 to 1
Thread1 update fail!

补充：AtomicMarkableReference 可以理解为前文 AtomicStampedReference 的简化版，就是不关心修改过几次，仅仅关心是否修改过。因此变量 mark 是 boolean 类型，仅记录值是否有过修改。

public class AtomicMarkableReference<V> {

    private static class Pair<T> {
        final T reference;
        final boolean mark;
        private Pair(T reference, boolean mark) {
            this.reference = reference;
            this.mark = mark;
        }
        static <T> Pair<T> of(T reference, boolean mark) {
            return new Pair<T>(reference, mark);
        }
    }

    private volatile Pair<V> pair;

二、Atomic

1、Atomic原子操作类介绍

在并发编程中很容易出现并发安全的问题，举个很简单的例子：多线程更新变量 i=1 ，若多个线程执行 i++ 操作，就有可能获取不到正确的值，解决此问题最常用的方法就是通过 synchronized 进行控制来达到线程安全的目的。

但由于synchronized采用的是悲观锁策略，一种比较低效的解决方案。实际上，在 J.U.C 下的 atomic 包中提供了一系列的操作简单、性能高效、且保证线程安全的类去更新基本类型变量、数组元素、引用类型及更新对象中的字段类型。

atomic 包下的这些类均采用的乐观锁策略进行原子更新数据，在 Java 中则是使用 CAS 操作具体实现。

在java.util.concurrent.atomic包里提供一组原子操作类：

1、基本类型

AtomicInteger、AtomicLong、AtomicBoolean；

2、引用类型

AtomicReference、AtomicStampedRerence、AtomicMarkableReference；

3、数组类型

AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray

4、对象属性原子修改器

AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater

5、原子类型累加器（JDK8增加的类）

DoubleAccumulator、DoubleAdder、LongAccumulator、LongAdder、Striped64

2、原子更新基本类型

以AtomicInteger为例总结常用的方法：

//以原子的方式将实例中的原值加1，返回的是自增前的旧值；
public final int getAndIncrement() {
	return unsafe.getAndAddInt(this, valueOffset, 1);
}

//getAndSet(int newValue)：将实例中的值更新为新值，并返回旧值；
public final boolean getAndSet(boolean newValue) {
	boolean prev;
	do {
		prev = get();
	} while (!compareAndSet(prev, newValue));
		return prev;
	}

//incrementAndGet() ：以原子的方式将实例中的原值进行加1操作，并返回最终相加后的结果；
public final int incrementAndGet() {
	return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

//addAndGet(int delta) ：以原子方式将输入的数值与实例中原本的值相加，并返回最后的结果；
public final int addAndGet(int delta) {
	return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}

测试：

public class AtomicIntegerTest {
    static AtomicInteger sum = new AtomicInteger(0);

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    //原子自增 CAS
                    sum.incrementAndGet();
                    //TODO
                }
            });
            thread.start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(sum.get());
    }
}

public final int incrementAndGet() {
	return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

incrementAndGet()方法通过CAS自增实现，如果CAS失败，自旋直到成功+1。

public final int getAndAddInt(Object var1, long var2, int var4) {
	int var5;

	//cas失败，自旋
	do {
		var5 = this.getIntVolatile(var1, var2);
	} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
		return var5;
	}

3、原子更新数组类型

AtomicIntegerArray为例总结常用的方法：

//addAndGet(int i, int delta)：以原子更新的方式将数组中索引为i的元素与输入值相加；
public final int addAndGet(int i, int delta) {
	return getAndAdd(i, delta) + delta;
}

//getAndIncrement(int i)：以原子更新的方式将数组中索引为i的元素自增加1；
public final int getAndIncrement(int i) {
	return getAndAdd(i, 1);
}

//compareAndSet(int i, int expect, int update)：将数组中索引为i的位置的元素进行更新
public final boolean compareAndSet(int i, int expect, int update) {
	return compareAndSetRaw(checkedByteOffset(i), expect, update);
}

测试：

public class AtomicIntegerArrayTest {
    static int[] value = new int[]{1, 2, 3, 4, 5};
    static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(value);

    public static void main(String[] args) {
        //设置索引0的元素为100
        atomicIntegerArray.set(0, 100);
        System.out.println(atomicIntegerArray.get(0));
        //以原子更新的方式将数组中索引为1的元素与输入值相加
        atomicIntegerArray.getAndAdd(1, 5);
        System.out.println(atomicIntegerArray);
    }
}

4、原子更新引用类型

AtomicReference作用是对普通对象的封装，它可以保证你在修改对象引用时的线程安全性。

public class AtomicReferenceTest {
    public static void main(String[] args) {
        User user1 = new User("张三", 23);
        User user2 = new User("李四", 30);
        User user3 = new User("王五", 18);

        //初始化为 user1
        AtomicReference<User> atomicReference = new AtomicReference<>();
        atomicReference.set(user1);

        //把 user2 赋给 atomicReference
        atomicReference.compareAndSet(user1, user2);
        System.out.println(atomicReference.get());

        //把 user3 赋给 atomicReference
        atomicReference.compareAndSet(user1, user3);
        System.out.println(atomicReference.get());
    }
}

@Data
@AllArgsConstructor
class User {
    private String name;
    public Integer age;
}

5、对象属性原子修改器

AtomicIntegerFieldUpdater可以线程安全地更新对象中的整型变量。

public class AtomicIntegerFieldUpdaterTest {
    public static class Candidate {
        volatile int score1 = 0;

        AtomicInteger score2 = new AtomicInteger();
    }

    public static final AtomicIntegerFieldUpdater<Candidate> scoreUpdater = 
    		AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score1");

    public static AtomicInteger realScore = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        final Candidate candidate = new Candidate();

        Thread[] t = new Thread[10000];
        for (int i = 0; i < 10000; i++) {
            t[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    if (Math.random() > 0.4) {
                        candidate.score2.incrementAndGet();
                        scoreUpdater.incrementAndGet(candidate);
                        realScore.incrementAndGet();
                    }
                }
            });
            t[i].start();
        }
        for (int i = 0; i < 10000; i++) {
            t[i].join();
        }
        System.out.println("AtomicIntegerFieldUpdater Score = " + candidate.score1);
        System.out.println("AtomicInteger Score = " + candidate.score2.get());
        System.out.println("realScore = " + realScore.get());
    }
}

对于 AtomicIntegerFieldUpdater 的使用稍微有一些限制和约束，约束如下：

字段必须是volatile类型的，在线程之间共享变量时保证立即可见
eg：volatile int value = 3
字段的描述类型（修饰符public/protected/default/private）与调用者与操作对象字段的关系一致。即调用者能直接操作对象字段，即可反射进行原子操作。但对于父类的字段，子类是不能直接操作，仅能访问父类的字段。
只能是实例变量，不能是类变量，即不能加 static 关键字。
只能是可修改变量，不能使用 final 变量，因为 final 的语义就是不可修改。实际上 final 的语义和 volatile 是有冲突的，这两个关键字不能同时存在。
对于 AtomicIntegerFieldUpdater 和 AtomicLongFieldUpdater 只能修改 int/long 类型的字段，不能修改其包装类型（Integer/Long）。如果要修改包装类型就需要使用 AtomicReferenceFieldUpdater。

6、LongAdder/DoubleAdder详解

AtomicLong 利用底层的 CAS 操作来提供并发性的，如addAndGet方法：

    public final long getAndAdd(long delta) {
        return unsafe.getAndAddLong(this, valueOffset, delta);
    }

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;
	}

上述方法调用了 Unsafe 类的 getAndAddLong 方法，该方法内部是个 native 方法，逻辑采用自旋方式不断更新目标值，直到更新成功。

在并发量较低的环境下，线程冲突的概率比较小，自旋的次数不会很多。

但是，在高并发环境下，N个线程同时进行自旋操作，会出现大量失败并不断自旋的情况，此时 AtomicLong 的自旋会成为瓶颈。

LongAdder 引入的初衷是为了解决高并发环境下 AtomicInteger，AtomicLong 的自旋瓶颈问题。

性能测试

public class LongAdderTest {
    public static void main(String[] args) {
        testAtomicLongVSLongAdder(10, 1000);
        System.out.println("==========");
        testAtomicLongVSLongAdder(10, 200000);
        System.out.println("==========");
        testAtomicLongVSLongAdder(100, 200000);
        System.out.println("==========");

    }

    static void testAtomicLongVSLongAdder(final int threadCount, final int times) {
        try {
            long start1 = System.currentTimeMillis();
            testLongAdder(threadCount, times);
            long end1 = System.currentTimeMillis() - start1;
            System.out.println("条件 >>> 线程数：" + threadCount + "，单线程操作计数：" + times);
            System.out.println("结果 >>> LongAdder方式增加计数：" + (threadCount * times) + "次，共计耗时：" + end1);

            long start2 = System.currentTimeMillis();
            testAtomicLong(threadCount, times);
            long end2 = System.currentTimeMillis() - start2;
            System.out.println("条件 >>> 线程数：" + threadCount + "，单线程操作计数：" + times);
            System.out.println("结果 >>> AtomicLong方式增加计数：" + (threadCount * times) + "次，共计耗时：" + end2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static void testAtomicLong(final int threadCount, final int times) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        AtomicLong atomicLong = new AtomicLong();
        for (int i = 0; i < threadCount; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < times; j++) {
                        atomicLong.incrementAndGet();
                    }
                    countDownLatch.countDown();
                }
            }, "my-thread" + i).start();
        }
        countDownLatch.await();
    }

    static void testLongAdder(final int threadCount, final int times) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(threadCount);
        LongAdder longAdder = new LongAdder();
        for (int i = 0; i < threadCount; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < times; j++) {
                        longAdder.add(1);
                    }
                    countDownLatch.countDown();
                }
            }, "my-thread" + i).start();
        }
        countDownLatch.await();
    }
}

测试结果：线程数越多，并发操作数越大，LongAdder 的优势越明显

条件 >>> 线程数：10，单线程操作计数：1000
结果 >>> LongAdder方式增加计数：10000次，共计耗时：3
条件 >>> 线程数：10，单线程操作计数：1000
结果 >>> AtomicLong方式增加计数：10000次，共计耗时：1
==========
条件 >>> 线程数：10，单线程操作计数：200000
结果 >>> LongAdder方式增加计数：2000000次，共计耗时：16
条件 >>> 线程数：10，单线程操作计数：200000
结果 >>> AtomicLong方式增加计数：2000000次，共计耗时：36
==========
条件 >>> 线程数：100，单线程操作计数：200000
结果 >>> LongAdder方式增加计数：20000000次，共计耗时：42
条件 >>> 线程数：100，单线程操作计数：200000
结果 >>> AtomicLong方式增加计数：20000000次，共计耗时：291
==========

低并发、一般的业务场景下 AtomicLong 足以。

若高并发量，且存在大量写多读少的情况时，LongAdder 则更合适。

7、LongAdder原理

设计思路

AtomicLong 中有个内部变量 value 保存着实际的 long 值，所有的操作都是针对该变量进行。即高并发环境下，value 变量为一个热点，也就是N个线程竞争一个热点。LongAdder 的基本思路就是分散热点，将 value 值分散到一个数组中，不同线程会命中到数组的不同槽中，各个线程只对自己槽中的那个值进行CAS操作，这样热点就被分散了，冲突的概率就小很多。若要获取真正的 long 值，只需将各个槽中的变量值累加返回。
在这里插入图片描述

8、LongAdder的内部结构

LongAdder 内部有一个 base 变量，一个 Cell[] 数组

base 变量：非竞态条件下，直接累加到该变量上

Cell[] 数组：竞态条件下，累加到各个线程自己的槽 Cell[i] 中

/** Number of CPUS, to place bound on table size */
// CPU核数，用来决定槽数组的大小
static final int NCPU = Runtime.getRuntime().availableProcessors();

/**
 * Table of cells. When non‐null, size is a power of 2.
 */
// 数组槽，大小为2的次幂
transient volatile Cell[] cells;

/**
 * Base value, used mainly when there is no contention, but also as
 * a fallback during table initialization races. Updated via CAS.
 */
/**
 * 基数，在两种情况下会使用：
 * 1. 没有遇到并发竞争时，直接使用base累加数值
 * 2. 初始化cells数组时，必须要保证cells数组只能被初始化一次（即只有一个线程能对cells初始化），
 * 其他竞争失败的线程会讲数值累加到base上
 */
transient volatile long base;

/**
 * Spinlock (locked via CAS) used when resizing and/or creating Cells.
 * 通过CAS实现的自旋锁标记
 * 扩容或创建新的Cells时使用此锁
 */
transient volatile int cellsBusy;

定义了一个内部 Cell 类，这就是我们之前所说的槽，每个 Cell 对象存有一个 value 值，可通过 Unsafe 来CAS操作：

@sun.misc.Contended static final class Cell {
    volatile long value;
    Cell(long x) { value = x; }
    final boolean cas(long cmp, long val) {
        return UNSAFE.compareAndSwapLong(this, valueOffset, cmp, val);
    }

    // Unsafe mechanics
    private static final sun.misc.Unsafe UNSAFE;
    private static final long valueOffset;
    static {
        try {
            UNSAFE = sun.misc.Unsafe.getUnsafe();
            Class<?> ak = Cell.class;
            valueOffset = UNSAFE.objectFieldOffset
                (ak.getDeclaredField("value"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
}

Contended解决伪共享问题

9、LongAdder#add方法

LongAdder#add方法的逻辑：
在这里插入图片描述
只有从未出现过并发冲突的时候，base 基数才会使用到，一旦出现了并发冲突，之后所有的操作都只针对 Cell[] 数组中的单元 Cell。

若 Cell[] 数组未初始化，会调用父类的 longAccumelate 去初始化 Cell[]；

若 Cell[] 已经初始化，但是冲突发生在 Cell 单元内，则也调用父类的 longAccumelate，此时可能就需要对 Cell[] 进行扩容。

此为 LongAdder 设计的精妙之处：尽量减少热点冲突，不到最后万不得已，尽量将CAS操作延迟。

10、Striped64#longAccumulate方法

整个Striped64#longAccumulate：
在这里插入图片描述

11、LongAdder#sum方法

/**
 * 返回累加的和，也就是"当前时刻"的计数值
 * 注意： 高并发时，除非全局加锁，否则得不到程序运行中某个时刻绝对准确的值
 * 此返回值可能不是绝对准确的，因为调用这个方法时还有其他线程可能正在进行计数累加,
 * 方法的返回时刻和调用时刻不是同一个点，在有并发的情况下，这个值只是近似准确的计数值
 */
public long sum() {
    Cell[] as = cells; Cell a;
    long sum = base;
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

由于计算总和时没有对 Cell[] 数组进行加锁，所以在累加过程中可能有其他线程对 Cell 中的值进行了修改，也有可能对数组进行了扩容，所以 sum 返回的值并不是非常精确的，其返回值并不是一个调用 sum 方法时的原子快照值。

12、LongAccumulator

LongAccumulator 是 LongAdder 的增强版。LongAdder 只能针对数值的进行加减运算，而 LongAccumulator 提供了自定义的函数操作。

构造函数：

public LongAccumulator(LongBinaryOperator accumulatorFunction, long identity) {
    this.function = accumulatorFunction;
    base = this.identity = identity;
}

通过 LongBinaryOperator，可自定义对入参的任意操作，并返回结果（LongBinaryOperator 接收2个 long 作为参数，并返回1个 long）。LongAccumulator 的内部原理和 LongAdder 几乎完全一样，都是利用了父类 Striped64 的 longAccumulate 方法。

public class LongAccumulatorTest {
    public static void main(String[] args) throws InterruptedException {
        //累加 x+y
        LongAccumulator accumulator = new LongAccumulator((x, y) -> x + y, 0);

        ExecutorService executor = Executors.newFixedThreadPool(8);
        //1到9累加
        IntStream.range(1, 10).forEach(i -> executor.submit(() -> accumulator.accumulate(i)));
        
        Thread.sleep(2000);
        System.out.println(accumulator.getThenReset());
    }
}

秋天的一亩三分地

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
关于CAS与Atomic原子操作

CAS（Compare And Swap，比较并交换），通常指的是这样一种原子操作：针对一个变量，首先比较它的内存值与某个期望值是否相同，如果相同，就给它赋一个新值。CAS 可以看作是它们合并后的整体——一个不可分割的原子操作，并且其原子性是直接在硬件层面得到保障的。CAS可以看做是乐观锁（对比数据库的悲观、乐观锁）的一种实现方式，Java原子类中的递增操作就通过CAS自旋实现的。CAS是一种无锁算法，在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。在并发编程中很容易出现并发安全的问题，举个很
复制链接

扫一扫

专栏目录