Java並行AtomicBoolean類


java.util.concurrent.atomic包裡,多了一批原子處理類。AtomicBooleanAtomicIntegerAtomicLongAtomicReference。主要用於在高並行環境下的高效程式處理,來幫助我們簡化同步處理.

AtomicInteger一個提供原子操作的Integer的類。在Java語言中,++ii++操作並不是執行緒安全的,在使用的時候,不可避免的會用到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關鍵字

優點總結:
最大的好處就是可以避免多執行緒的優先順序倒置和死鎖情況的發生,提升在高並行處理下的效能。