java.util.concurrent的AtomicInteger類詳解

java.util.concurrent包下面有不少原子性的線程安全的數據結構的實現。研究一下經常使用的AtomicInteger類。

AtomicInteger類對應着經常使用的int類型，看一下它如何實現原子性的。

static {
  try {
    valueOffset = unsafe.objectFieldOffset
        (AtomicInteger.class.getDeclaredField("value"));
  } catch (Exception ex) { throw new Error(ex); }
}
private volatile int value;
public AtomicInteger(int initialValue) {
    value = initialValue;
}
public AtomicInteger() {
}

static塊裏面的看不懂。裏面的unsafe會在後面提到。

下面的代碼能夠看出，基本的數據存數是靠volatile int value來實現的。

可是volatile關鍵字是實現不了併發安全的（volatile關鍵字詳解），他對數據操做的方法確定是還有其餘緣由。

get()、set()等不對原有值依賴的方法volatile就能夠實現指望的功能。咱們看一下

getAndIncrement（）、incrementAndGet（）等方法是如何實現的。

public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

關鍵的是compareAndSet(current,next)方法的實現。

/**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return true if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

能夠看到它的註解說明，當value與當前指望的值相等的時候，原子性的更新value。照這樣說就實現了併發安全，但他到底怎麼實現的呢？

下面是Unsafe類中的方法

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

不是用Java實現的, 而是經過JNI調用操做系統的原生程序.一般狀況下週到這裏就中止了，但在網上找了一下，有說明，水平還沒到能本身往下搞明白。

下面都是截取的網上的說明：

compareAndSwapInt的native實現
若是你下載了OpenJDK的源代碼的話在hotspot\src\share\vm\prims\目錄下能夠找到unsafe.cpp

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj);
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset);
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e;
UNSAFE_END

能夠看到實際上調用Atomic類的cmpxchg方法.

Atomic的cmpxchg
這個類的實現是跟操做系統有關, 跟CPU架構也有關, 若是是windows下x86的架構
實如今hotspot\src\os_cpu\windows_x86\vm\目錄的atomic_windows_x86.inline.hpp文件裏

inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  // alternative for InterlockedCompareExchange
  int mp = os::is_MP();
  __asm {
    mov edx, dest
    mov ecx, exchange_value
    mov eax, compare_value
    LOCK_IF_MP(mp)
    cmpxchg dword ptr [edx], ecx
  }
}

在這裏能夠看到是用嵌入的彙編實現的, 關鍵CPU指令是 cmpxchg
到這裏無法再往下找代碼了. 也就是說CAS的原子性其實是CPU實現的. 其實在這一點上仍是有排他鎖的. 只是比起用synchronized, 這裏的排他時間要短的多. 因此在多線程狀況下性能會比較好.

代碼裏有個alternative for InterlockedCompareExchange
這個InterlockedCompareExchange是WINAPI裏的一個函數, 作的事情和上面這段彙編是同樣的
http://msdn.microsoft.com/en-us/library/windows/desktop/ms683560%28v=vs.85%29.aspx

最後再貼一下x86的cmpxchg指定

Opcode CMPXCHG

CPU: I486+ 
Type of Instruction: User 

Instruction: CMPXCHG dest, src 

Description: Compares the accumulator with dest. If equal the "dest" 
is loaded with "src", otherwise the accumulator is loaded 
with "dest". 

Flags Affected:	AF, CF, OF, PF, SF, ZF 

CPU mode: RM,PM,VM,SMM 
+++++++++++++++++++++++ 
Clocks: 
CMPXCHG reg, reg	6 
CMPXCHG mem, reg	7 (10 if compartion fails)

後面在網上截取的這段引自http://www.blogjava.net/mstar/archive/2013/04/24/398351.html

C語言的東西都忘乾淨了，看不太懂了，最後的CPU的實現更看不明白了。可是知道了它是併發安全的是在cpu層實現的，目測效率應該比synchronized高。

這裏還有兩篇文章，一篇是Volatile、AtomicLong、synchronized三者效率的http://hehongwei44.iteye.com/blog/1244732

一篇是volatile正確使用場景的http://www.ibm.com/developerworks/cn/java/j-jtp06197.html