AtomicInteger這個類的存在是為了滿足在高併發的情況下,原生的整形數值自增執行緒不安全的問題。比如說

    int i = 0 ;
    i++;

上面的寫法是執行緒不安全的。
有的人可能會說了,可以使用synchronized關鍵字啊。
但是這裡筆者要說的是,使用了synchronized去做同步的話系統的效能將會大大下降。
所以此時AtomicInteger這個類的使用就可以滿足上述的情況。
當我們統計一個頁面的瀏覽量的時候,可以使用該類來統計,而不再使用++運算子。

但是在使用的過程中,筆者發現,使用++運算子和AtomicInteger的結果都是對的。。。

結果有點暈了,難道結論是錯的麼?當然不是了。
注意這個類使用的情況下是在高併發量的情況下。不是同時啟10個20個執行緒,而是成千上萬個執行緒。

我們先看看AtomicInteger類起作用的程式碼

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

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

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

        Thread.sleep(3000);
        System.out.println("最終結果是" + atomicInteger.get());
    }

    private  static void atomicIntegerTest() {
        ExecutorService executorService = Executors.newFixedThreadPool(10000
 
);
        for (int i = 0; i < 10000; i++) {
            executorService.execute(() -> {
                for (int j = 0; j < 4; j++) {
                    System.out.println(atomicInteger.getAndIncrement());
                }
            });
        }
        executorService.shutdown();
    }
}

列印的結果是4萬

再看看++操作符

    import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class IntValueIncrementTest {

    public static int value = 0;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10000);
        for (int i = 0; i < 10000; i++) {
            executorService.execute(() -> {
                for (int j = 0; j < 4; j++) {
                    System.out.println(value++);
                }
            });
        }
        executorService.shutdown();
        Thread.sleep(3000);
        System.out.println("最終結果是" + value);
    }
}

我們可以看到結果是39972,顯然結果丟失了一些。
所以在高併發的情況下應當使用AtomicInteger類

當我們在併發情況下,但是併發量又不是那麼大的時候,
我們將上述的程式碼改掉,改為同時只有10個執行緒在修改數值。
我們貼程式碼

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicInteger;

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

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

        Thread.sleep(3000);
        System.out.println("最終結果是" + atomicInteger.get());
    }

    private  static void atomicIntegerTest() {
        ExecutorService executorService = Executors.newFixedThreadPool(10000);
        for (int i = 0; i < 10; i++) {
            executorService.execute(() -> {
                for (int j = 0; j < 4; j++) {
                    System.out.println(atomicInteger.getAndIncrement());
                }
            });
        }
        executorService.shutdown();
    }
}

執行的結果是40

再貼10個執行緒的併發量的情形。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class IntValueIncrementTest {

    public static int value = 0;

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(10000);
        for (int i = 0; i < 10; i++) {
            executorService.execute(() -> {
                for (int j = 0; j < 4; j++) {
                    System.out.println(value++);
                }
            });
        }
        executorService.shutdown();
        Thread.sleep(3000);
        System.out.println("最終結果是" + value);
    }
}

發現此時的結果也是40。
所以這就給人一種假象:
1)AtomicInteger類不起作用.
2)i++或者++i是執行緒安全的
其實上面兩點觀念都是錯誤的。是因為併發量不夠高而已
但是需要注意的是AtomicInteger類只能保證在自增或者自減的情況下保證執行緒安全