死磕 java原子類之終結篇（面試題）

時間 2019-11-13

標籤 java 子類終結面試欄目 Java 简体版

原文原文鏈接

概覽

原子操做是指不會被線程調度機制打斷的操做，這種操做一旦開始，就一直運行到結束，中間不會有任何線程上下文切換。java

原子操做能夠是一個步驟，也能夠是多個操做步驟，可是其順序不能夠被打亂，也不能夠被切割而只執行其中的一部分，將整個操做視做一個總體是原子性的核心特徵。數據庫

在java中提供了不少原子類，筆者在此主要把這些原子類分紅四大類。數組

原子更新基本類型或引用類型

若是是基本類型，則替換其值，若是是引用，則替換其引用地址，這些類主要有：緩存

（1）AtomicBoolean安全

原子更新布爾類型，內部使用int類型的value存儲1和0表示true和false，底層也是對int類型的原子操做。架構

（2）AtomicInteger分佈式

原子更新int類型。ide

（3）AtomicLong源碼分析

原子更新long類型。性能

（4）AtomicReference

原子更新引用類型，經過泛型指定要操做的類。

（5）AtomicMarkableReference

原子更新引用類型，內部使用Pair承載引用對象及是否被更新過的標記，避免了ABA問題。

（6）AtomicStampedReference

原子更新引用類型，內部使用Pair承載引用對象及更新的郵戳，避免了ABA問題。

這幾個類的操做基本相似，底層都是調用Unsafe的compareAndSwapXxx()來實現，基本用法以下：

private static void testAtomicReference() {
    AtomicInteger atomicInteger = new AtomicInteger(1);
    atomicInteger.incrementAndGet();
    atomicInteger.getAndIncrement();
    atomicInteger.compareAndSet(3, 666);
    System.out.println(atomicInteger.get());

    AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);
    atomicStampedReference.compareAndSet(1, 2, 1, 3);
    atomicStampedReference.compareAndSet(2, 666, 3, 5);
    System.out.println(atomicStampedReference.getReference());
    System.out.println(atomicStampedReference.getStamp());
}

原子更新數組中的元素

原子更新數組中的元素，能夠更新數組中指定索引位置的元素，這些類主要有：

（1）AtomicIntegerArray

原子更新int數組中的元素。

（2）AtomicLongArray

原子更新long數組中的元素。

（3）AtomicReferenceArray

原子更新Object數組中的元素。

這幾個類的操做基本相似，更新元素時都要指定在數組中的索引位置，基本用法以下：

private static void testAtomicReferenceArray() {
    AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(10);
    atomicIntegerArray.getAndIncrement(0);
    atomicIntegerArray.getAndAdd(1, 666);
    atomicIntegerArray.incrementAndGet(2);
    atomicIntegerArray.addAndGet(3, 666);
    atomicIntegerArray.compareAndSet(4, 0, 666);
    
    System.out.println(atomicIntegerArray.get(0));
    System.out.println(atomicIntegerArray.get(1));
    System.out.println(atomicIntegerArray.get(2));
    System.out.println(atomicIntegerArray.get(3));
    System.out.println(atomicIntegerArray.get(4));
    System.out.println(atomicIntegerArray.get(5));
}

原子更新對象中的字段

原子更新對象中的字段，能夠更新對象中指定字段名稱的字段，這些類主要有：

（1）AtomicIntegerFieldUpdater

原子更新對象中的int類型字段。

（2）AtomicLongFieldUpdater

原子更新對象中的long類型字段。

（3）AtomicReferenceFieldUpdater

原子更新對象中的引用類型字段。

這幾個類的操做基本相似，都須要傳入要更新的字段名稱，基本用法以下：

private static void testAtomicReferenceField() {
    AtomicReferenceFieldUpdater<User, String> updateName = AtomicReferenceFieldUpdater.newUpdater(User.class, String.class,"name");
    AtomicIntegerFieldUpdater<User> updateAge = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");

    User user = new User("tong ge", 21);
    updateName.compareAndSet(user, "tong ge", "read source code");
    updateAge.compareAndSet(user, 21, 25);
    updateAge.incrementAndGet(user);
    
    System.out.println(user);
}

private static class User {
    volatile String name;
    volatile int age;

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

    @Override
    public String toString() {
        return "name: " + name + ", age: " + age;
    }
}

高性能原子類

高性能原子類，是java8中增長的原子類，它們使用分段的思想，把不一樣的線程hash到不一樣的段上去更新，最後再把這些段的值相加獲得最終的值，這些類主要有：

（1）Striped64

下面四個類的父類。

（2）LongAccumulator

long類型的聚合器，須要傳入一個long類型的二元操做，能夠用來計算各類聚合操做，包括加乘等。

（3）LongAdder

long類型的累加器，LongAccumulator的特例，只能用來計算加法，且從0開始計算。

（4）DoubleAccumulator

double類型的聚合器，須要傳入一個double類型的二元操做，能夠用來計算各類聚合操做，包括加乘等。

（5）DoubleAdder

double類型的累加器，DoubleAccumulator的特例，只能用來計算加法，且從0開始計算。

這幾個類的操做基本相似，其中DoubleAccumulator和DoubleAdder底層其實也是用long來實現的，基本用法以下：

private static void testNewAtomic() {
    LongAdder longAdder = new LongAdder();
    longAdder.increment();
    longAdder.add(666);
    System.out.println(longAdder.sum());

    LongAccumulator longAccumulator = new LongAccumulator((left, right)->left + right * 2, 666);
    longAccumulator.accumulate(1);
    longAccumulator.accumulate(3);
    longAccumulator.accumulate(-4);
    System.out.println(longAccumulator.get());
}