原子變量類

從JDK1.5開始提供了java.util.concurrent.atomic包，方便程序員在多線程環(huán)境下，無鎖的進(jìn)行原子操作。原子變量的底層使用了處理器提供的原子指令，但是不同的CPU架構(gòu)可能提供的原子指令不一樣，也有可能需要某種形式的內(nèi)部鎖，所以該方法不能絕對(duì)保證線程不被阻塞。

在Atomic包里一共有12個(gè)類，四種原子更新方式，分別是原子更新基本類型，原子更新數(shù)組，原子更新引用和原子更新字段。Atomic包里的類基本都是使用Unsafe實(shí)現(xiàn)的包裝類。

原子更新基本類型類

用于通過原子的方式更新基本類型，Atomic包提供了以下三個(gè)類：

1. AtomicBoolean：原子更新布爾類型。
2. AtomicInteger：原子更新整型。
3. AtomicLong：原子更新長整型。

AtomicInteger的常用方法如下：

• int addAndGet(int delta) ：以原子方式將輸入的數(shù)值與實(shí)例中的值（AtomicInteger里的value）相加，并返回結(jié)果。
• boolean compareAndSet(int expect, int update) ：如果實(shí)例中的值與預(yù)期值相等，則把實(shí)例中的值更新為最新值。
• int getAndIncrement()：以原子方式將當(dāng)前值加1，注意：這里返回的是自增前的值。
• void lazySet(int newValue)：最終會(huì)設(shè)置成newValue，使用lazySet設(shè)置值后，可能導(dǎo)致其他線程在之后的一小段時(shí)間內(nèi)還是可以讀到舊的值。
• int getAndSet(int newValue)：以原子方式設(shè)置為newValue的值，并返回舊值。

AtomicInteger例子代碼如下：

public class AtomicIntegerTest {

    static AtomicInteger ai = new AtomicInteger(1);

    public static void main(String[] args) {
        System.out.println(ai.getAndIncrement());
        System.out.println(ai.get());
    }

}

輸出結(jié)果：

1

2

Atomic包提供了三種基本類型的原子更新，但是Java的基本類型里還有char，float和double等。那么問題來了，如何原子的更新其他的基本類型呢？Atomic包里的類基本都是使用Unsafe實(shí)現(xiàn)的，讓我們一起看下Unsafe的源碼，發(fā)現(xiàn)Unsafe只提供了三種CAS方法，compareAndSwapObject，compareAndSwapInt和compareAndSwapLong，再看AtomicBoolean源碼，發(fā)現(xiàn)其是先把Boolean轉(zhuǎn)換成整型，再使用compareAndSwapInt進(jìn)行CAS，所以原子更新double也可以用類似的思路來實(shí)現(xiàn)。

原子更新數(shù)組類

通過原子的方式更新數(shù)組里的某個(gè)元素，Atomic包提供了以下三個(gè)類：

1. AtomicIntegerArray：原子更新整型數(shù)組里的元素。
2. AtomicLongArray：原子更新長整型數(shù)組里的元素。
3. AtomicReferenceArray：原子更新引用類型數(shù)組里的元素。

AtomicIntegerArray類主要是提供原子的方式更新數(shù)組里的整型，其常用方法如下：

• int addAndGet(int i, int delta)：以原子方式將輸入值與數(shù)組中索引i的元素相加。
• boolean compareAndSet(int i, int expect, int update)：如果當(dāng)前值等于預(yù)期值，則以原子方式將數(shù)組位置i的元素設(shè)置成update值。

實(shí)例代碼如下：

public class AtomicIntegerArrayTest {

    static int[] value = new int[] { 1, 2 };

    static AtomicIntegerArray ai = new AtomicIntegerArray(value);

    public static void main(String[] args) {
        ai.getAndSet(0, 3);
        System.out.println(ai.get(0));
                System.out.println(value[0]);
    }

}

輸出結(jié)果如下：

3

1

AtomicIntegerArray類需要注意的是，數(shù)組value通過構(gòu)造方法傳遞進(jìn)去，然后AtomicIntegerArray會(huì)將當(dāng)前數(shù)組復(fù)制一份，所以當(dāng)AtomicIntegerArray對(duì)內(nèi)部的數(shù)組元素進(jìn)行修改時(shí)，不會(huì)影響到傳入的數(shù)組。

原子更新引用類型

原子更新基本類型的AtomicInteger，只能更新一個(gè)變量，如果要原子的更新多個(gè)變量，就需要使用這個(gè)原子更新引用類型提供的類。Atomic包提供了以下三個(gè)類：

1. AtomicReference：原子更新引用類型。
2. AtomicReferenceFieldUpdater：原子更新引用類型里的字段。
3. AtomicMarkableReference：原子更新帶有標(biāo)記位的引用類型?？梢栽拥母乱粋€(gè)布爾類型的標(biāo)記位和引用類型。構(gòu)造方法是AtomicMarkableReference(V initialRef, boolean initialMark)

AtomicReference的使用例子代碼如下：

public class AtomicReferenceTest {

    public static AtomicReference<user> atomicUserRef = new AtomicReference<user>();

    public static void main(String[] args) {
        User user = new User("conan", 15);
        atomicUserRef.set(user);
        User updateUser = new User("Shinichi", 17);
        atomicUserRef.compareAndSet(user, updateUser);
        System.out.println(atomicUserRef.get().getName());
        System.out.println(atomicUserRef.get().getOld());
    }

    static class User {
        private String name;
        private int old;

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

        public String getName() {
            return name;
        }

        public int getOld() {
            return old;
        }
    }
}

輸出結(jié)果：

Shinichi

17

原子更新字段類

如果我們只需要某個(gè)類里的某個(gè)字段，那么就需要使用原子更新字段類，Atomic包提供了以下三個(gè)類：

1. AtomicIntegerFieldUpdater：原子更新整型的字段的更新器。
2. AtomicLongFieldUpdater：原子更新長整型字段的更新器。
3. AtomicStampedReference：原子更新帶有版本號(hào)的引用類型。該類將整數(shù)值與引用關(guān)聯(lián)起來，可用于原子的更數(shù)據(jù)和數(shù)據(jù)的版本號(hào)，可以解決使用CAS進(jìn)行原子更新時(shí)，可能出現(xiàn)的ABA問題。

原子更新字段類都是抽象類，每次使用都時(shí)候必須使用靜態(tài)方法newUpdater創(chuàng)建一個(gè)更新器。原子更新類的字段的必須使用public volatile修飾符。AtomicIntegerFieldUpdater的例子代碼如下：

public class AtomicIntegerFieldUpdaterTest {

    private static AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater
            .newUpdater(User.class, "old");

    public static void main(String[] args) {
        User conan = new User("conan", 10);
        System.out.println(a.getAndIncrement(conan));
        System.out.println(a.get(conan));
    }

    public static class User {
        private String name;
        public volatile int old;

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

        public String getName() {
            return name;
        }

        public int getOld() {
            return old;
        }
    }
}

輸出結(jié)果：

10

11

性能比較：鎖與原子變量

原子變量比鎖的粒度更細(xì)，量級(jí)更輕，并且對(duì)于在多處理器系統(tǒng)上實(shí)現(xiàn)高性能的并發(fā)代碼來說是非常關(guān)鍵的。原子變量將發(fā)生競爭的范圍縮小到單個(gè)變量上，這是你獲得的粒度最細(xì)的情況（假設(shè)算法能夠基于這種細(xì)粒度來實(shí)現(xiàn)）。更新原子變量的快速（非競爭）路徑不會(huì)比獲取鎖的快速路徑慢，并且通常會(huì)更快，而它的慢速路徑肯定比鎖的慢速路徑快，因?yàn)樗恍枰獟炱鸹蛑匦抡{(diào)度線程。在使用基于原子變量而非鎖的算法中，線程在執(zhí)行時(shí)更不易出現(xiàn)延遲，并且如果遇到競爭，也更容易恢復(fù)過來。

偽隨機(jī)數(shù)生成器（PRNG），在PRNG中，在生成下一個(gè)隨機(jī)數(shù)字時(shí)需要用到上一個(gè)數(shù)字，所以在PRNG中必須記錄前一個(gè)數(shù)值并將其作為狀態(tài)的一部分。

以下給出了線程安全的PRNG的兩種實(shí)現(xiàn)，一種使用ReentrantLock，另一種使用AtomicInteger。測試程序?qū)⒎磸?fù)調(diào)用它們，在每次迭代中將生成一個(gè)隨機(jī)數(shù)字（在此過程中將讀取并修改共享的seed狀態(tài)），并執(zhí)行一些僅在線程本地?cái)?shù)據(jù)上執(zhí)行的“繁忙”迭代。這種方法模擬了一些典型的操作，以及一些在共享狀態(tài)以及線程本地狀態(tài)上的操作。

基于ReentrantLock實(shí)現(xiàn)的隨機(jī)數(shù)生成器：

public class ReentrantLockPseudoRandom extends PseudoRandom{  
  
    private final Lock lock = new ReentrantLock(false);  
    private int seed;  
      
    ReentrantLockPseudoRandom(int seed){  
        this.seed = seed;  
    }  
    public int nextInt(int n){  
        lock.lock();  
        try{  
            int s = seed;  
            seed = calculateNext(s);  
            int remainder = s % n;  
            return remainder >0 ? remainder : remainder+n;  
        }finally{  
            lock.unlock();  
        }  
    }  
}  

基于AtomicInteger實(shí)現(xiàn)的隨機(jī)數(shù)生成器：

public class AtomicPseudoRandom extends PseudoRandom{  
  
    private AtomicInteger seed;  
    AtomicPseudoRandom(int seed){  
        this.seed = new AtomicInteger(seed);  
    }  
  
    public int nextInt(int n){  
        while(true){  
            int s = seed.get();  
            int nextSeed = calculateNext(s);  
            if(seed.compareAndSet(s, nextSeed)){  
                int remainder = s % n;  
                return remainder > 0 ? remainder : remainder + n;  
            }  
        }  
    }  
}  

下圖給出了在每次迭代中工作量較高以及適中情況下的吞吐量。如果線程本地的計(jì)算量較少，那么在鎖和原子變量上的競爭將非常激烈。如果線程本地的計(jì)算量較多，那么在鎖和原子變量上的競爭將會(huì)降低。因?yàn)樵诰€程中訪問鎖和原子變量的頻率將降低。

從這些圖中可以看出，在高度競爭的情況下，鎖的性能將超過原子變量的性能，但在更真實(shí)的競爭情況下，原子變量的性能將超過鎖的性能。這是因?yàn)殒i在發(fā)生競爭時(shí)會(huì)掛起線程，從而降低了CPU的使用率和共享內(nèi)存總線上的同步通信量（這類似于生產(chǎn)者--消費(fèi)者設(shè)計(jì)中的可阻塞生產(chǎn)者，它能降低消費(fèi)者上的工作負(fù)載，使消費(fèi)者的處理速度趕上生產(chǎn)者的處理速度。）另一方面，如果使用原子變量，那么發(fā)出調(diào)用的類負(fù)責(zé)對(duì)競爭進(jìn)行管理。與大多數(shù)基于CAS的算法一樣，AtomicPseudoRandom在遇到競爭時(shí)將立即重試，這通常是一種正確的方法，但在激烈競爭環(huán)境下卻導(dǎo)致了更多的競爭。下面兩個(gè)圖是粗略圖，數(shù)值對(duì)應(yīng)沒那么精確，但足以表達(dá)相互之間的性能高低。

image.png

<center>在競爭程度較高情況下的Lock與AtomicInteger的性能</center>

image.png

<center>在競爭程度適中情況下的Lock與AtomicInteger的性能</center>

在批評(píng)AtomicPseudoRandom寫的太糟糕或者原子變量比鎖更糟糕之前，應(yīng)該意識(shí)到一圖中競爭級(jí)別過高而有些不切實(shí)際：任何一個(gè)真實(shí)的程序都不會(huì)除了競爭鎖或原子變量，其它什么工作都不做。在實(shí)際情況中，原子變量在可伸縮性上要高于鎖，因?yàn)樵趹?yīng)對(duì)常見的競爭程度時(shí)，原子變量的效率會(huì)更高。

在中低端程度的競爭下，原子變量能提供更高的可伸縮性，而在高強(qiáng)度的競爭下，鎖能夠更有效地避免競爭。（在單CPU的系統(tǒng)上，基于CAS的算法在性能上同樣會(huì)超過基于鎖的算法，因?yàn)镃AS在單CPU的系統(tǒng)上通常能執(zhí)行成功，只有在偶然情況下，線程才會(huì)在執(zhí)行讀-改-寫的操作過程中被其它線程搶占執(zhí)行。）

上兩個(gè)圖中都包含了第三條曲線，它是一個(gè)使用了ThreadLocal來保存PRNG狀態(tài)的PseudoRandom。這種實(shí)現(xiàn)方法改變了類的行為，即每個(gè)線程都只能看到自己私有的偽隨機(jī)數(shù)字序列，而不是所有線程共享同一個(gè)隨機(jī)數(shù)序列，這說明了，如果能夠避免使用共享狀態(tài)，那么開銷將會(huì)更小。我們可以通過提高處理競爭的效率來提高可伸縮性，但只有完全消除競爭，才能實(shí)現(xiàn)真正的可伸縮性。