Java併發AtomicBoolean類

在java.util.concurrent.atomic包裏，多了一批原子處理類。AtomicBoolean、AtomicInteger、AtomicLong、AtomicReference。主要用於在高併發環境下的高效程式處理,來幫助我們簡化同步處理.

AtomicInteger一個提供原子操作的Integer的類。在Java語言中，++i和i++操作並不是線程安全的，在使用的時候，不可避免的會用到synchronized關鍵字。而AtomicInteger則通過一種線程安全的加減操作介面。

我們先來看看AtomicInteger提供了什麼介面:

public final int get() //獲取當前的值

public final int getAndSet(int newValue)//獲取當前的值，並設置新的值

public final int getAndIncrement()//獲取當前的值，並自增

public final int getAndDecrement() //獲取當前的值，並自減

public final int getAndAdd(int delta) //獲取當前的值，並加上預期的值

下麵通過兩個簡單的例子來看一下 AtomicInteger 的優勢。

普通線程同步:

class Test2 {
        private volatile int count = 0;

        public synchronized void increment() {
                  count++; //若要線程安全執行執行count++，需要加鎖

        }

        public int getCount() {
                  return count;
        }
}

使用AtomicInteger來實現:

class Test2 {
        private AtomicInteger count = new AtomicInteger();

        public void increment() {
                  count.incrementAndGet();
        }
   //使用AtomicInteger之後，不需要加鎖，也可以實現線程安全。

       public int getCount() {
                return count.get();
        }
}

從上面的例子中我們可以看出：使用AtomicInteger是非常的安全的。而且因為AtomicInteger由硬體提供原子操作指令實現的。在非激烈競爭的情況下，開銷更小，速度更快。

我們來看看AtomicInteger是如何使用非阻塞演算法來實現併發控制的:
AtomicInteger的關鍵域只有一下3個：

// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;
static {
         try {
                valueOffset = unsafe.objectFieldOffset (AtomicInteger.class.getDeclaredField("value"));
        } catch (Exception ex) {
               throw new Error(ex);
        }
    }
private volatile int value;

這裏， unsafe是java提供的獲得對對象記憶體地址訪問的類，注釋已經清楚的寫出了，它的作用就是在更新操作時提供“比較並替換”的作用。實際上就是AtomicInteger中的一個工具。
valueOffset是用來記錄value本身在內存的便宜地址的，這個記錄，也主要是為了在更新操作在內存中找到value的位置，方便比較。
注意：value是用來存儲整數的時間變數，這裏被聲明為volatile，就是為了保證在更新操作時，當前線程可以拿到value最新的值(併發環境下，value可能已經被其他線程更新了)。
這裏，我們以自增的代碼為例，可以看到這個併發控制的核心演算法：

/**
*Atomicallyincrementsbyonethecurrentvalue.
*
*@returntheupdatedvalue
*/
publicfinalintincrementAndGet(){
    for(;;){
        //這裏可以拿到value的最新值

        intcurrent=get();
        intnext=current+1;
        if(compareAndSet(current,next)){
            returnnext;
        }

    }
}

publicfinalbooleancompareAndSet(intexpect,intupdate){
//使用unsafe的native方法，實現高效的硬體級別CAS
        returnunsafe.compareAndSwapInt(this,valueOffset,expect,update);
}

性能對比測試

下麵是一個對比測試，我們寫一個synchronized的方法和一個AtomicInteger的方法來進行測試，直觀的感受下性能上的差異。

package zl.study.concurrency;
import java.util.concurrent.atomic.AtomicInteger;
public class AtomicIntegerCompareTest {
    private int value;

    public AtomicIntegerCompareTest(int value){
        this.value = value;
    }

    public synchronized int increase(){
        return value++;
    }

    public static void main(String args[]){
        long start = System.currentTimeMillis();

        AtomicIntegerCompareTest test = new AtomicIntegerCompareTest(0);
        for( int i=0;i< 1000000;i++){
            test.increase();
        }
        long end = System.currentTimeMillis();
        System.out.println("time elapse:"+(end -start));

        long start1 = System.currentTimeMillis();

        AtomicInteger atomic = new AtomicInteger(0);

        for( int i=0;i< 1000000;i++){
            atomic.incrementAndGet();
        }
        long end1 = System.currentTimeMillis();
        System.out.println("time elapse:"+(end1 -start1) );


    }
}

結果 -

time elapse:31
time elapse:16

由此不難看出，通過JNI本地的CAS性能遠超synchronized關鍵字

優點總結:
最大的好處就是可以避免多線程的優先順序倒置和死鎖情況的發生，提升在高併發處理下的性能。