Java原子類中的AtomicInteger類詳解

更新時間：2023年10月24日 09:34:08 作者：liyong0829

這篇文章主要介紹了Java原子類中的AtomicInteger類詳解,原子類可以保證對"變量"操作的,原子性、有序性、可見性,我們可以通過AtomicInteger類,來看看它們是怎樣工作的,需要的朋友可以參考下

原子類

在java.util.concurrent.atomic包下定義了一些對“變量”操作的“原子類”:

java.util.concurrent.atomic.AtomicInteger：對int變量操作的“原子類”;
java.util.concurrent.atomic.AtomicLong：對long變量操作的“原子類”;
java.util.concurrent.atomic.AtomicBoolean：對boolean變量操作的“原子類”;

它們可以保證對“變量”操作的：原子性、有序性、可見性。

AtomicInteger類示例

我們可以通過AtomicInteger類，來看看它們是怎樣工作的

//線程類：

public class MyThread extends Thread {
     //static int a = 0;
    static AtomicInteger a = new AtomicInteger();// 表示整數(shù)0

    @Override
    public void run() {
        for (int i = 0; i < 200000; i++) {
            // a++;
            a.getAndIncrement();
        }
        System.out.println("子線程執(zhí)行完畢");
    }
}

//測試類：

public class Test {
    public static void main(String[] args) throws InterruptedException {

        // 案例:一條子線程和一條主線程都對共享變量a進行++操作,每條線程對a++操作400000次
        new MyThread().start();

        for (int i = 0; i < 200000; i++) {
            //MyThread.a++;
            MyThread.a.getAndIncrement();
        }

        // 為了保證子線程和主線程都執(zhí)行完畢
        Thread.sleep(3000);

        // 打印最終共享變量a的值(子線程,主線程對a的操作都執(zhí)行完畢了)
        System.out.println("最終:"+ MyThread.a.get());

  }
}

我們能看到，無論程序運行多少次，其結果總是正確的！

AtomicInteger類的工作原理-CAS機制

在這里插入圖片描述

AtomicIntegerArray類示例

常用的數(shù)組操作的原子類：

1).java.util.concurrent.atomic.AtomicIntegerArray:對int數(shù)組操作的原子類。 int[]

2).java.util.concurrent.atomic.AtomicLongArray：對long數(shù)組操作的原子類。long[]

3).java.util.concurrent.atomic.AtomicReferenceArray：對引用類型數(shù)組操作的原子類。Object[]

數(shù)組的多線程并發(fā)訪問的安全性問題：

//線程類：

public class MyThread extends Thread {
    public static int[] arr = new int[1000];

    @Override
    public void run() {
        for (int i = 0; i < arr.length(); i++) {
            arr[i]++;
        }
        System.out.println("結束");
    }
}

//測試類：

public class Demo {
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 1000; i++) {
            new MyThread().start();//創(chuàng)建1000個線程，每個線程為數(shù)組的每個元素+1
        }

        Thread.sleep(1000 * 5);//讓所有線程執(zhí)行完畢

        System.out.println("主線程休息5秒醒來");
        for (int i = 0; i < MyThread.arr.length; i++) {
            System.out.println(MyThread.arr[i]);
        }
    }
}

//正常情況，數(shù)組的每個元素最終結果應為：1000，而實際打?。?/p>

1000
1000
1000
1000
999
999
999
999
999
999
999
999
1000
1000
1000
1000

可以發(fā)現(xiàn)，有些元素并不是1000.

//為保證數(shù)組的多線程安全，改用AtomicIntegerArray類，演示：

//線程類：

public class MyThread extends Thread {
 
    //改用原子類，使用數(shù)組構造
    public static AtomicIntegerArray arr = new AtomicIntegerArray(1000);
    @Override
    public void run() {
        for (int i = 0; i < arr.length(); i++) {
            arr.addAndGet(i, 1);//將i位置上的元素 + 1
        }
        System.out.println("結束");
    }
}

測試類

  public class Demo {
      public static void main(String[] args) throws InterruptedException {
          for (int i = 0; i < 1000; i++) {
              new MyThread().start();
          }
          Thread.sleep(1000 * 5);//讓所有線程執(zhí)行完畢
  
          System.out.println("主線程休息5秒醒來");
          for (int i = 0; i < MyThread.arr.length(); i++) {
              System.out.println(MyThread.arr.get(i));
          }
      }
  }

先在能看到，每次運行的結果都是正確的。

到此這篇關于Java原子類中的AtomicInteger類詳解的文章就介紹到這了,更多相關Java的AtomicInteger類內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: