如何理解Java多線程原子操作類

本篇內容主要講解“如何理解Java多線程原子操作類”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“如何理解Java多線程原子操作類”吧!

目錄

• 1、What and Why

• 2、原子更新基本類型類

• 3、實現原理

• 4、原子更新數組

• 5、原子更新引用類型

• 6、原子更新字段類

1、What and Why

原子的本意是不能被分割的粒子，而對于一個操作來說，如果它是不可被中斷的一個或者一組操作，那么他就是原子操作。顯然，原子操作是安全的，因為它不會被打斷。

平時我們見到的很多操作看起來是原子操作，但其實是非原子操作，例如很常見的i++操作，它背后有取值、加一、寫回等操作，如果有兩個線程都要對 i 進行加一操作，就有可能結果把i只變成了2，這就是線程不安全的更新操作，當然我們可以使用synchronized解決，但是JUC提供了java.util.concurrent.atomic包，這個包的原子操作類提供了一種簡單高效、線程安全地更新一個變量的方式。

2、原子更新基本類型類

使用原子的方式更新基本類型，Atomic包提供了以下3個類：

• AtomicBoolean：原子更新布爾類型

• AtomicInteger：原子更新整型

• AtomicLong：原子更新長整型
  

上面三個類型的方法幾乎一模一樣，下面以AtomicInteger為例介紹以下他們的方法

• int addAndGet(int data)：以原子操作的方式將輸入data與AtomicInteger原有的值相加，并返回結果。

• boolean compareAndSet(int expect, int update)：如果輸入的數值等于預期值expect，則以原子操作的方式將update賦給AtomicInteger原有的值。

• getAndIncrement()：以原子操作的方式給AtomicInteger原有的值加一，但是注意這個方法返回的值是自增前的值。

• int getAndSet(int newValue)：以原子操作的方式給AtomicInteger原有的值設置成newValue的值

• void lazySet(int newValue)：最終會設置成newValue，但是使用lazyset設置之后，可能會導致其他線程在之后的一小段時間內還可以讀到舊值。

class AtomicIntegerDemo{

    static AtomicInteger atomicInteger = new AtomicInteger(0);

    public static void main(String[] args) {



        //新建一個線程池
        ExecutorService threadPoolExecutor = new ThreadPoolExecutor(2,
                4,
                100,
                TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<Runnable>(10),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

    // 新建一個線程
    threadPoolExecutor.execute(
        () -> {
          for (int i = 0; i < 10; i++) {
              atomicInteger.incrementAndGet();
          }

        });

        //新建一個線程
        threadPoolExecutor.execute(()->{
            for (int i = 0; i < 10; i++) {
                atomicInteger.incrementAndGet();
            }
        });

        System.out.println(atomicInteger.get());
        threadPoolExecutor.shutdown();
    }
}

3、實現原理

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

其中，unsafe類是Java用來處理一些用于執行低級別、不安全操作的方法，如直接訪問系統內存資源、自主管理內存資源等，它使得Java擁有了類似C語言一樣操作內存空間的能力。

valueOffset是字段value的內存偏移地址，valueOffset的值在AtomicInteger初始化時，在靜態代碼塊中通過Unsafe的objectFieldOffset方法獲取。在AtomicInteger中提供的線程安全方法中，通過字段valueOffset的值可以定位到AtomicInteger對象中value的內存地址，從而可以根據CAS實現對value字段的原子操作。

public final int getAndAddInt(Object o, long offset, int delta) {
        int v;
        do {
            v = getIntVolatile(o, offset);
        } while (!compareAndSwapInt(o, offset, v, v + delta));
        return v;
    }

打開getAndAddInt()函數，可以看到這里使用了一個CAS機制的自旋鎖來對v值進行賦值,關于CAS機制可以查看文章Java多線程 樂觀鎖和CAS機制
，getIntVolatile方法用于獲取對象o指定偏移量的int值，此操作具有volatile內存語義，也就是說，即使對象o指定offset的變量不是volatile的，次操作也會使用volatile語義，會強制從主存獲取值，然后通過compareAndSwapInt來替換值，直到替換成功后，退出循環。

4、原子更新數組

使用原子的方式更新數組中的某個元素，Atomic包提供了以下3個類：

• AtomicReferenceArray：原子更新引用類型數組中的元素

• AtomicIntegerArray：原子更新整型數組中的元素

• AtomicLongArray：原子更新長整型數組中的元素

下面以AtomicIntegerArray為例介紹以下他們的方法：

1. int addAndGet(int i, int delta)：以原子的方式將輸入值與數組中索引i的元素相加。

2. boolean compareAndSet(int i, int expect, int update)：如果當前值等于預期值，則以原子方式將數組位置i的元素設置成update值

5、原子更新引用類型

剛剛提到的只能一次更新一個變量，如果要更新多個變量就需要使用原子更新引用類型提供的類了：

• AtomicReference：原子更新引用類型

• AtomicReferenceFieldUpdater：原子更新引用類型里的字段

• AtomicMarkableReference：原子更新帶有標記位的引用類型。可以原子地更新一個布爾類型地標記位和引用類型。

AtomicReference 示例

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

class Reference
{
    static AtomicReference<User> atomicUser = new AtomicReference<>();

    public static void main(String[] args) {

        User u = new User("1",10);
        atomicUser.set(u);
        System.out.println(atomicUser.get());
        atomicUser.compareAndSet(u,new User("2",15));
        System.out.println(atomicUser.get());
        System.out.println(atomicUser.compareAndSet(u, new User("3", 123)));
        System.out.println(atomicUser.compareAndSet(new User("2", 15), u));
    }
}

AtomicReferenceFieldUpdate

class AtomicFiled
{
    static AtomicReferenceFieldUpdater<User,String> nameField = AtomicReferenceFieldUpdater.newUpdater(User.class,String.class,"name");

    public static void main(String[] args) {
        //
        User u = new User("123",10);
        System.out.println(u);

        System.out.println(nameField.compareAndSet(u, "123", "xiaohua"));
        System.out.println(u);
        System.out.println(nameField.compareAndSet(u,"123","xiaoli"));
    }
}

AtomicMarkableReference 示例

前面介紹的都是在原子操作下對一個數據進行修改，AtomicMarkableReference 不同的是，它不僅可以修改，還定義了一個變量去判斷是他之前是否已經被修改過了，這里就不得不提到ABA問題了：

ABA問題就是如果一個線程把變量a的值由1變成2，另一個線程又把變量a的值由2變回了1，這個時候變量a的值相當于沒有變過，但實際上其實已經被更改了，這就是ABA問題。可以舉一個更形象的例子，杯子里有一杯水，小明把它喝完了，之后又接滿水放回原處，這時小華來了如果知道了杯子被人用過那肯定不會再喝了，如果小明喝完之后那張紙記錄下已經用過，那么小華來了就知道了。AtomicMarkableReference就提供了這樣一個布爾變量記錄值是否被修改過。

AtomicMarkableReference初始化時需要傳入一個引用值（類型就是前面填的泛型），此外還需要傳入一個布爾值用作判斷是否修改。AtomicMarkableReference的compareAndSet要傳入兩組參數：舊的引用值和新的引用值；舊的布爾值和新的布爾值，只有傳入的舊引用值和舊布爾值與對象中的值相同，才會修改引用值和布爾值。

class AtomicFiled
{

    static AtomicMarkableReference<Integer> intMarkable = new AtomicMarkableReference<>(123,false);

    public static void main(String[] args) {

        System.out.println(intMarkable.getReference());
        System.out.println(intMarkable.isMarked());
        System.out.println(intMarkable.compareAndSet(123,100,false,true));
        System.out.println(intMarkable.getReference());
        System.out.println(intMarkable.isMarked());
        System.out.println(intMarkable.compareAndSet(100,123,false,true));

    }
}

6、原子更新字段類

如果需要原子地更新某個類中的字段時，就需要使用原子更新字段類，Atomic包提供了下面3個類：

1. AtomicIntegerFieldUpdater：原子更新整型的字段的更新器

2. AtomicLongFieldUpdater：原子更新長整型的字段的更新器

3. AtomicStampedReference：原子更新帶版本號的引用類型。使用版本號解決ABA問題

需要注意的是，原子地更新字段類需要兩步：第一步需要用靜態方法newUpdate()創建一個更新器，并且設置想要更新的類和屬性。第二步，更新類的字段（屬性）必須使用public volatile修飾符。

public class AtomicDemo {
    static AtomicReference<User> atomicUsers = new AtomicReference<>();
    static AtomicIntegerFieldUpdater<User> userAge = AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
    static CountDownLatch countDownLatch = new CountDownLatch(2);

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

          User u = new User("123",0);
          atomicUsers.set(u);
          ExecutorService threadPoolExecutor = new ThreadPoolExecutor(3,
                  6,
                  100,
                  TimeUnit.MILLISECONDS,
                  new ArrayBlockingQueue<Runnable>(10),
                  Executors.defaultThreadFactory(),
                  new ThreadPoolExecutor.AbortPolicy());
          threadPoolExecutor.execute(()->
          {

              try {
                  TimeUnit.MILLISECONDS.sleep(200);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              System.out.println(Thread.currentThread().getName()+"  "+atomicUsers.get().getAge());
              userAge.incrementAndGet(u);
             countDownLatch.countDown();
          });

          threadPoolExecutor.shutdown();
          countDownLatch.await();
          System.out.println(atomicUsers.get().getAge());
  }
}

到此，相信大家對“如何理解Java多線程原子操作類”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！