基本資料型別

AtomicBoolean、AtomicLong、AtomicInteger 這三個類提供了一些對基本資料型別的變數值進行原子更新的方法，

這些類提供的方法是相似的，主要有（以 AtomicLong 為例）：

// 原子化的 i++
long getAndIncrement()
// 原子化的 i--
long getAndDecrement()

// 原子化的 ++i
long incrementAndGet()
// 原子化的 --i
long decrementAndGet()

// 原子化的 i+=delta，回傳值為+=前的i值
long getAndAdd(long delta)
// 原子化的 i+=delta，回傳值為+=后的i值
long addAndGet(delta)

// CAS操作，如果寫回成功回傳true，否則回傳false
boolean compareAndSet(long expect, long update)

// 以下四個方法新值可以通過傳入函式式介面(func函式)來計算
long getAndUpdate(LongUnaryOperator updateFunction)
long updateAndGet(LongUnaryOperator updateFunction)
long getAndAccumulate(long x, LongBinaryOperator accumulatorFunction)
long accumulateAndGet(long x, LongBinaryOperator accumulatorFunction)

// 演示 getAndUpdate() 方法的使用
public static void main(String[] args) {
    AtomicLong atomicLong = new AtomicLong(0);
    long result = atomicLong.getAndUpdate(new LongUnaryOperator() {
        @Override
        public long applyAsLong(long operand) {
            return operand + 1;
        }
    });
}

物件參考型別

AtomicReference、AtomicStampedReference、AtomicMarkableReference 這三個類提供了一些對物件變數的指向進行原子更新的方法，如果需要對物件的屬性進行原子更像，那么可以使用原子化的物件屬性更新器，

public class ClassName {
    AtomicReference<Employee> employeeAR = new AtomicReference<>(new Employee("小明"));

    public void methodName() {
        Employee oldVal = employeeAR.get();
        Employee newVal = new Employee(oldVal.getName());
        employeeAR.compareAndSet(oldVal, newVal);
    }
}

物件參考的原子化更新需要重點關注 ABA 問題，當一個執行緒在進行 CAS 操作時，另一個執行緒可能會在此期間修改了同一個共享變數的值，然后又將其改回原來的值，這種情況下，CAS 操作就無法檢測到共享變數值的變化，從而導致 ABA 問題，如果我們僅僅在寫回資料前判斷數值是 A，可能導致不合理的寫回操作，AtomicStampedReference 和 AtomicMarkableReference 這兩個原子類可以解決 ABA 問題，

AtomicStampedReference 通過為物件參考建立類似版本號（stamp）的方式，來解決 ABA 問題，AtomicStampedReference 實作的 CAS 方法增加了版本號引數
AtomicMarkableReference 的實作機制則更簡單，將版本號簡化成了一個 Boolean 值

boolean compareAndSet(V expectedReference, V newReference, 
                          int expectedStamp, int newStamp)

boolean compareAndSet(V expectedReference, V newReference,
                          boolean expectedMark, boolean newMark)

陣列

AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray 這三個類提供了一些對陣列里面的的元素進行原子更新的方法，

public class ClassName {
    AtomicLongArray atomicLongArray = new AtomicLongArray(new long[]{0, 1});

    public void methodName() {
        int index = 0;
        long oldVal = atomicLongArray.get(index);
        long newVal = oldVal + 1;
        atomicLongArray.compareAndSet(index, oldVal, newVal);
    }
}

原子化的物件屬性更新器

原子化的物件屬性更新器有：AtomicIntegerFieldUpdater、AtomicLongFieldUpdater、AtomicReferenceFieldUpdater，

這三個類提供了一些對物件的屬性進行原子更新的方法，這些方法是利用反射機制實作的，

public class ClassName {
    AtomicIntegerFieldUpdater<Employee> fieldUpdater =
            AtomicIntegerFieldUpdater.newUpdater(Employee.class, "salary");

    Employee employee = new Employee("小明", 1000);

    public void methodName() {
        int oldVal = employee.getSalary();
        int newVal = oldVal + 1000;
        fieldUpdater.compareAndSet(employee, oldVal, newVal);
    }
}

需要注意的是：

物件屬性的型別必須是基本資料型別，不能是基本資料型別對應的包裝類，如果物件屬性的型別不是基本資料型別，newUpdater() 方法會拋出 IllegalArgumentException 運行時例外，
物件的屬性必須是 volatile 型別的，只有這樣才能保證可見性，如果物件的屬性不是 volatile 型別的，newUpdater() 方法會拋出 IllegalArgumentException 運行時例外，

// AtomicIntegerFieldUpdater 類中的代碼
if (field.getType() != int.class) {
    throw new IllegalArgumentException("Must be integer type");
}

if (!Modifier.isVolatile(modifiers)) {
    throw new IllegalArgumentException("Must be volatile type");
}

原子化的累加器

原子化的累加器有：LongAdder、DoubleAdder、LongAccumulator、DoubleAccumulator，這四個類僅僅用來在多執行緒環境下，執行累加操作，

相比原子化的基本資料型別，原子化的累加器的速度更快，但是它（原子化的累加器）不支持 compareAndSet() 方法，如果僅僅需要累加操作，使用原子化的累加器性能會更好，

原子化的累加器的本質是空間換時間，

LongAdder 的使用示例如下所示：

public static void main(String[] args) {
    LongAdder adder = new LongAdder();
    // 初始化
    adder.add(1);
    // 累加
    for (int i = 0; i < 100; i++) {
        adder.increment();
    }
    long sum = adder.sum();
}

LongAccumulator 與 LongAdder 類似，但 LongAccumulator 提供了更加靈活的累加操作，可以自定義累加函式，

使用示例如下所示，在使用示例中，我們創建了一個 LongAccumulator 物件，初始值為1，累加函式為 (x, y) -> x * y，即每次累加都將之前的結果與新的值相乘，然后，我們累加了三個數值，最后輸出累加結果，由于累加函式是(x, y) -> x * y，所以最終的累加結果為1 * 5 * 10 * 20 = 1000，

public static void main(String[] args) {
    LongAccumulator accumulator = new LongAccumulator(new LongBinaryOperator() {
        @Override
        public long applyAsLong(long left, long right) {
            return left * right;
        }
    }, 1);
    // 初始值為1，累加函式為(x, y) -> x * y
    accumulator.accumulate(5);
    accumulator.accumulate(10);
    accumulator.accumulate(20);
    // 累加結果為 1 * 5 * 10 * 20 = 1000
    long result = accumulator.get();
}

參考資料

21 | 原子類：無鎖工具類的典范 (geekbang.org)

本文來自博客園，作者：真正的飛魚，轉載請注明原文鏈接：https://www.cnblogs.com/feiyu2/p/atomic.html

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/553518.html

標籤：其他

上一篇：Hackathon 代碼黑客馬拉松采訪復盤

下一篇：返回列表

Java的Atomic原子類

基本資料型別

物件參考型別

陣列

原子化的物件屬性更新器

原子化的累加器

參考資料