2. 程式人生 > >Java併發--原子變數類的使用

Java併發--原子變數類的使用

阿新 • • 發佈：2018-12-13

注：本篇部落格主要內容來源於網路，侵刪~

引言

我們假設你已經熟練掌握了CAS，原子變數類等的相關概念。這篇部落格中，我們主要討論原子變數類的使用。

原子變數類

原子變數類共12個，分4組：

  1. 計數器：AtomicInteger，AtomicLong，AtomicBoolean，AtomicReference。
  2. 域更新器：AtomicIntegerFieldUpdater，AtomicLongFieldUpdater，AtomicReferenceFieldUpdater。
  3. 陣列：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray。
  4. 複合變數：AtomicMarkableReference，AtomicStampedReference。

在每組中我會選擇其中一個較有代表性的進行分析與舉例。

AtomicReference

使用說明

AtomicReference的作用是對"物件"進行原子操作。

原始碼分析
public class AtomicReference<V> implements java.io.Serializable {
    private static final long serialVersionUID = -1848883965231344442L;
 
    // 獲取Unsafe物件，Unsafe的作用是提供CAS操作
 

    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;
 
    static {
        try {
            // 獲取相應欄位相對Java物件的“起始地址”的偏移量
            valueOffset = unsafe.objectFieldOffset
                (AtomicReference.class.getDeclaredField("value"));
        }
 
 catch (Exception ex) { throw new Error(ex); }
    }
 
    // volatile型別
    private volatile V value;
 
    public AtomicReference(V initialValue) {
        value = initialValue;
    }
 
    public AtomicReference() {
    }
 
    public final V get() {
        return value;
    }
 
    public final void set(V newValue) {
        value = newValue;
    }
 
    public final void lazySet(V newValue) {
        unsafe.putOrderedObject(this, valueOffset, newValue);
    }
 
    public final boolean compareAndSet(V expect, V update) {
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
    }
 
    public final boolean weakCompareAndSet(V expect, V update) {
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
    }
 
    public final V getAndSet(V newValue) {
        while (true) {
            V x = get();
            if (compareAndSet(x, newValue))
                return x;
        }
    }
 
    public String toString() {
        return String.valueOf(get());
    }
}

關於上述程式碼只有兩點需要強調：

  1. valueOffset = unsafe.objectFieldOffset(AtomicReference.class.getDeclaredField("value")) 通過相關欄位的偏移量獲取值比直接使用反射獲取相應欄位的值效能要好許多；
使用舉例
class Person {
    volatile long id;
    
    public Person(long id) {
        this.id = id;
    }
    
    public String toString() {
        return "id:" + id;
    }
}

public class AtomicReferenceTest {
    public static void main(String[] args) {
        // 建立兩個Person物件，它們的id分別是101和102。
        Person p1 = new Person(101);
        Person p2 = new Person(102);
        // 新建AtomicReference物件，初始化它的值為p1物件
        AtomicReference ar = new AtomicReference(p1);
        
        // 通過CAS設定ar。如果ar的值為p1的話，則將其設定為p2。
        ar.compareAndSet(p1, p2);
 
        Person p3 = (Person)ar.get();
        System.out.println("p3 is "+p3);
        System.out.println("p3.equals(p1)="+p3.equals(p1));
    }
}

AtomicReferenceFieldUpdater

接下來所有的原子變數類不再進行原始碼分析。事實上所有原子變數類的實現都大同小異，感興趣的同學可以閱讀原始碼。

使用說明

一個基於反射的工具類，它能對指定類的指定的volatile引用欄位進行原子更新。(注意這個欄位不能是private的)

通過呼叫AtomicReferenceFieldUpdater的靜態方法newUpdater就能建立它的例項，該方法要接收三個引數：

  1. 包含該欄位的物件的類;
  2. 將被更新的物件的類;
  3. 將被更新的欄位的名稱。
使用舉例
class Dog {  
    volatile String name = "dog1";
}  

public class App {
    public static void main(String[] args) throws Exception {
        AtomicReferenceFieldUpdater updater = AtomicReferenceFieldUpdater.newUpdater(Dog.class, String.class, "name");
        Dog dog1 = new Dog();
        updater.compareAndSet(dog1, dog1.name, "test");
        
        System.out.println(dog1.name);
    }
}

AtomicReferenceArray

使用說明

可以用原子方式更新其元素的物件引用陣列。

以下是AtomicReferenceArray類中可用的重要方法的列表：

序列 方法 描述
1 public AtomicReferenceArray(int length) 建構函式，建立給定長度的新 AtomicReferenceArray。
2 public AtomicReferenceArray(E[] array) 建構函式，建立與給定陣列具有相同長度的新 AtomicReferenceArray，並從給定陣列複製其所有元素。
3 public boolean compareAndSet(int i, E expect, E update) 如果當前值==期望值，則將位置i處的元素原子設定為給定的更新值。
4 public E get(int i) 獲取位置i的當前值。
5 public E getAndSet(int i, E newValue) 將位置i處的元素原子設定為給定值，並返回舊值。
6 public void set(int i, E newValue) 將位置i處的元素設定為給定值。
使用舉例
public class TestThread {
    // 建立原子引用陣列
    private static String[] source = new String[10];
    private static AtomicReferenceArray<String> atomicReferenceArray = new AtomicReferenceArray<String>(source);

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < atomicReferenceArray.length(); i++) {
            atomicReferenceArray.set(i, "item-2");
        }

        Thread t1 = new Thread(new Increment());
        Thread t2 = new Thread(new Compare());
        t1.start();
        t2.start();

        t1.join();
        t2.join();        
    }
    
    static class Increment implements Runnable {
        public void run() {
            for(int i = 0; i < atomicReferenceArray.length(); i++) {
                String add = atomicReferenceArray.getAndSet(i, "item-" + (i+1));
                System.out.println("Thread " + Thread.currentThread().getId() 
                    + ", index " + i + ", value: " + add);
            }
        }
    }
    
    static class Compare implements Runnable {
        public void run() {
            for(int i = 0; i< atomicReferenceArray.length(); i++) {
                System.out.println("Thread " + Thread.currentThread().getId() 
                    + ", index " + i + ", value: " + atomicReferenceArray.get(i));
                boolean swapped = atomicReferenceArray.compareAndSet(i, "item-2", "updated-item-2");
                System.out.println("Item swapped: " + swapped);
                if(swapped) {
                    System.out.println("Thread " + Thread.currentThread().getId() 
                        + ", index " + i + ", updated-item-2");
                }
            }
        }
    }
}

AtomicStampedReference

使用說明

AtomicStampedReference主要用來解決在使用CAS演算法的過程中，可能會產生的ABA問題。一般我們會使用帶有版本戳version的記錄或物件標記來解決ABA問題，AtomicStampedReference實現了這個作用，它通過包裝[E, Integer]的元組來對物件標記版本戳stamp。

以下是AtomicStampedReference類中可用的重要方法的列表：

序列 方法 描述
1 public AtomicStampedReference(V initialRef, int initialStamp) 構造方法，傳入引用和戳。
2 public boolean compareAndSet(V expectedReference, V newReference, int expectedStamp, int newStamp) 如果當前引用 == 預期值並且當前版本戳 == 預期版本戳，將更新新的引用和新的版本戳到記憶體。
3 public void set(V newReference, int newStamp) 設定當前引用的新引用和版本戳。
4 public boolean attemptStamp(V expectedReference, int newStamp) 如果當前引用 == 預期引用，將更新新的版本戳到記憶體。
使用舉例

下面的程式碼分別用AtomicInteger和AtomicStampedReference來對初始值為100的原子整型變數進行更新，AtomicInteger會成功執行CAS操作，而加上版本戳的AtomicStampedReference對於ABA問題會執行CAS失敗：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

public class ABA {
    private static AtomicInteger atomicInt = new AtomicInteger(100);
    private static AtomicStampedReference atomicStampedRef = new AtomicStampedReference(100, 0);

    public static void main(String[] args) throws InterruptedException {
        Thread intT1 = new Thread(new Runnable() {
            @Override
            public void run() {
                atomicInt.compareAndSet(100, 101);
                atomicInt.compareAndSet(101, 100);
            }
        });

        Thread intT2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
                boolean c3 = atomicInt.compareAndSet(100, 101);
                System.out.println(c3);         // true
            }
        });

        intT1.start();
        intT2.start();
        intT1.join();
        intT2.join();

        Thread refT1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                }
                atomicStampedRef.compareAndSet(100, 101, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
                atomicStampedRef.compareAndSet(101, 100, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
            }
        });

        Thread refT2 = new Thread(new Runnable() {
            @Override
            public void run() {
                int stamp = atomicStampedRef.getStamp();
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                }
                boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp + 1);
                System.out.println(c3);         // false
            }
        });

        refT1.start();
        refT2.start();
    }
}

效能比較：鎖與原子變數

事實上，CAS的效能總是優於鎖。我們分兩種情況進行討論。

1. 執行緒間競爭程度較高

對於鎖來說，激烈的競爭意味著執行緒頻繁的掛起與恢復，頻繁的上下文切換，這些操作都是非常耗費系統資源的；對於CAS演算法來說，激烈的競爭意味著執行緒將對競爭進行頻繁的處理（重試，回退，放棄等策略）。

即使如此，一般來說，CAS演算法的效能依舊優於鎖。

2. 執行緒間競爭程度較低

較低的競爭程度意味著CAS操作總是能夠成功；對於鎖來說，雖然鎖之間的競爭度也隨之下降，但由於獲取鎖與釋放鎖的操作不但耗費系統資源，並且其中本身就包含著CAS操作，因此在這種情況下，CAS操作的效能依舊優於鎖。

總結

  1. 這篇部落格並沒有講述CAS操作以及可能產生的ABA問題，但是我們必須熟悉這兩個知識點；
  2. 這篇部落格的主要目的是構建起大家對原子變數類的一個認識，以至於在以後的專案開發中，可以去思考如何使用這些原子變數類；
  3. 對於原子變數與鎖之間的優勢與劣勢，效能間的比較，有一個較為清晰的認識。

參考閱讀

Java併發程式設計實戰

相關推薦

Java併發--原子變數類的使用

注：本篇部落格主要內容來源於網路，侵刪~ 引言 我們假設你已經熟練掌握了CAS，原子變數類等的相關概念。這篇部落格中，我們主要討論原子變數類的使用。 原子變數類 原子變數類共12個，分4組： 計數器：AtomicInteger，AtomicLong，Atom

Java併發 --- 原子變數

Java 併發 --原子變數 原子變量出現的原因 --併發 鎖的劣勢 Sysnred 當多個執行緒爭用鎖時，JVM 會藉助作業系統的功能掛起執行緒，等待之後再被恢復（如果用了自旋鎖就不一定會被掛起），這裡的主要開銷就來自於執行緒的掛起和恢復。除此之外，鎖還有可能會帶來類

Java併發-對容器類的原子操作

我們知道很多Java容器類都是非執行緒安全的，比如常用的ArrayList就是非執行緒安全的，表現在併發場景下，經常出現莫名其妙的錯誤，看個例子： public class ConcurrentAccessListTest { public static List

全面瞭解 Java 原子變數類

Java 併發：Thread 類深度解析

摘要： 　　Java 中 Thread類 的各種操作與執行緒的生命週期密不可分，瞭解執行緒的生命週期有助於對Thread類中的各方法的理解。一般來說，執行緒從最初的建立到最終的消亡，要經歷建立、就緒、執行、阻塞 和 消亡 五個狀態。線上程的生命週期中，上下文切

Java 併發 ---原子操作的實現原理

注：本文部分參考了 java 併發程式設計的藝術一書 併發這塊反覆研究挺久了，原始碼也研究了一部分，總覺得缺乏一點認識，想了許久還是總結出來，這樣也有助於自己理解 原子操作意思為不可被中斷的一個或一系列操作 在瞭解原子操作的實現原理前，先要了解一下相關的術

java併發-原子性和可見性（7）

原子性:某個操作同時只能由一個執行緒執行。 可見性:一個執行緒的修改對其他執行緒是可見的。也就是A執行緒修改了變數x，那麼B,C,D...執行緒此時去拿到的x肯定是A修改之後的值。 package com.concurenny.chapter.six; /** * 建

java併發程式設計常用類

　在java 1.5中，提供了一些非常有用的輔助類來幫助我們進行併發程式設計，比如CountDownLatch，CyclicBarrier和Semaphore，今天我們就來學習一下這三個輔助類的用法。 　　以下是本文目錄大綱： 　　一.CountDownL

java併發之原子操作類(AtomicLong原始碼分析)和非阻塞演算法

  背景 近年來，在併發演算法領域的大多數研究都側重於非阻塞演算法，這種演算法用底層的原子機器指令（例如比較併發交換指令）代替鎖來確保資料在併發訪問中的一致性。非阻塞演算法被廣泛的用於在作業系統和JVM中實現執行緒/程序排程機制、垃圾回收機制以及鎖和其他併發資料結構。 與基於鎖

Java併發程式設計（十一）Java中的原子操作類

一、原子操作類簡介 JDK1.5開始提供了java.util.concurrent.atomic包，其中有一系列用法簡單、效能高效、可以執行緒安全更新變數的原子操作類，目前（JDK1.7）大概有這麼些： 二、原子操作類實現原理 以AtomicInteger為例看下原始碼，其中的兩個

（2.1.27.4）Java併發程式設計：原子類Atomic

在Java中的併發包中了提供了以下幾種型別的原子類來來解決執行緒安全的問題。分為 基本資料型別原子類 陣列型別原子類 引用型別原子類 欄位型別原子類。 因為其內部原理都差不多一致。這裡會對每種型別的原子類抽一個來介紹。 一、原子類的使用方式 public c

併發：Java中的13個原子操作類。

當程式更新一個變數時，如果多執行緒同時更新這個變數，可能得到期望之外的值，比如變數i=1，A執行緒更新i+1，B執行緒也更新i+1，經過兩個執行緒操作之後可能i不等於3，而是等於2。因為A和B執行緒在更新變數i的時候拿到的i都是1，這就是執行緒不安全的更新操作，通常我們會使用synchronized

《JAVA併發程式設計實戰》原子變數和非阻塞同步機制

引言 即使原子變數沒有用於非阻塞演算法的開發，他們也可以用作一種“更好的”volatile型別變數。原子變數提供了與volatile型別變數相同的記憶體語義，此外還支援原子的更新操作，從而使他們更加適用於實現計數器、序列發生器和統計資料收集等，同時還能比基於鎖

Java併發程式設計系列之十九：原子操作類

原子操作類簡介 當更新一個變數的時候，多出現資料爭用的時候可能出現所意想不到的情況。這時的一般策略是使用synchronized解決，因為synchronized能夠保證多個執行緒不會同時更新該變數。然而，從jdk 5之後，提供了粒度更細、量級更輕，並且在多核

java併發中的原子變數和原子操作以及CAS介紹

      很多情況下我們只是需要一個簡單的、高效的、執行緒安全的遞增遞減方案。注意，這裡有三個條件：簡單，意味著程式設計師儘可能少的操作底層或者實現起來要比較容易；高效意味著耗用資源要少，程式處理速度要快；執行緒安全也非常重要，這個在多執行緒下能保證資料的正確性。這三個條件看起來比較簡單，但是實現起來卻難

Java併發程式設計之原子操作類

原子操作類簡介 當更新一個變數的時候，多出現資料爭用的時候可能出現所意想不到的情況。這時的一般策略是使用synchronized解決，因為synchronized能夠保證多個執行緒不會同時更新該變數。然而，從jdk 5之後，提供了粒度更細、量級更輕，並且在多核處理器具有高效

Java多執行緒（二）之Atomic：原子變數與原子類

一、何謂Atomic？  Atomic一詞跟原子有點關係，後者曾被人認為是最小物質的單位。計算機中的Atomic是指不能分割成若干部分的意思。如果一段程式碼被認為是Atomic，則表示這段程式碼在

Java併發程式設計札記-(三)JUC原子類-07CAS

CAS，即compare and swap，比較並交換。CAS操作包含三個運算元：記憶體值（V），預期值（A）、新值（B）。如果記憶體值與預期值相同，就將記憶體值修改為新值，否則不做任何操作。 java.util.concurrent.atomic是建立在CA

Java併發程式設計札記-(三)JUC原子類-05原子方式更新類的指定volatile欄位

AtomicReferenceFieldUpdater、AtomicIntegerFieldUpdater和AtomicLongFieldUpdater是基於反射的實用工具，可以提供對關聯欄位型別的訪問。例如AtomicLongFieldUpdater可以對指定

Java併發學習筆記(九)-原子類AtomicInteger

AtomicInteger能夠保證對一個整型的操作是原子性。像i++這個操作不是原子操作，存在競態條件，所以需要加鎖，但是加鎖的效能不高，如果僅僅為了對一個整數加1。我們來看下他的實現。 private volatile int value; AtomicInte