Java util.concurrent包AtomicXXX系列对象在C#中的实现

（本文作者温少，首发于博客园，转载请注明）

从JDK 1.5开始，util.concurrent包提供了Atomic类型，包括AtomicInteger、AtomicLong、AtomicBoolean、AtomicReference、AtomicFieldUpdate等，这些类在并发编程中大有作用。

我原先以为JDK中的Atomic在Windows下实现是调用<windows.h>中InterLockedXXX系列函数实现的，但后来查看了JDK的源码，发现和原先想像中的不一样。JVM的实现中，封装了一个Atomic的类，然后不同的操作系统有不同的实现，例如，在JDK 1.6源码hotspot\src\os_cpu\win32_i486\vm\atomic_win32_i486.inline.hpp文件中：

inline jlong    Atomic::cmpxchg    (jlong    exchange_value, volatile jlong*    dest, jlong    compare_value) {
  int mp = os::is_MP();
  jint ex_lo  = (jint)exchange_value;
  jint ex_hi  = *( ((jint*)&exchange_value) + 1 );
  jint cmp_lo = (jint)compare_value;
  jint cmp_hi = *( ((jint*)&compare_value) + 1 );
  __asm {
    push ebx
    push edi
    mov eax, cmp_lo
    mov edx, cmp_hi
    mov edi, dest
    mov ebx, ex_lo
    mov ecx, ex_hi
    LOCK_IF_MP(mp)
    cmpxchg8b qword ptr [edi]
    pop edi
    pop ebx
  }
}

C#也提供了同样的能力，System.Threading.Interlocked封装了<windows.h>中的 InterlockedXXX系列函数，可以实现同样的功能，但是直接使用InterLocked没有象Java中的Atomic系列对象方便。

了解清楚Java中的AtomicXXX和.NET中InterLockedXXX系列函数之后，把Java的AtomicXXX系列对象在C#上重新实现一遍是很容易的事情。例如实现AtomicInteger：

public class AtomicInteger
{
    private int value;

    public AtomicInteger(int initialValue)
    {
        value = initialValue;
    }

    public AtomicInteger()
        : this(0)
    {
    }

    public int Get()
    {
        return value;
    }

    public void Set(int newValue)
    {
        value = newValue;
    }

    public int GetAndSet(int newValue)
    {
        for (; ; )
        {
            int current = Get();
            if (CompareAndSet(current, newValue))
                return current;
        }
    }

    public bool CompareAndSet(int expect, int update)
    {
        return Interlocked.CompareExchange(ref value, update, expect) == expect;
    }

    public int GetAndIncrement()
    {
        for (; ; )
        {
            int current = Get();
            int next = current + 1;
            if (CompareAndSet(current, next))
                return current;
        }
    }

    public int GetAndDecrement()
    {
        for (; ; )
        {
            int current = Get();
            int next = current - 1;
            if (CompareAndSet(current, next))
                return current;
        }
    }

    public int GetAndAdd(int delta)
    {
        for (; ; )
        {
            int current = Get();
            int next = current + delta;
            if (CompareAndSet(current, next))
                return current;
        }
    }

    public int IncrementAndGet()
    {
        for (; ; )
        {
            int current = Get();
            int next = current + 1;
            if (CompareAndSet(current, next))
                return next;
        }
    }

    public int DecrementAndGet()
    {
        for (; ; )
        {
            int current = Get();
            int next = current - 1;
            if (CompareAndSet(current, next))
                return next;
        }
    }

    public int AddAndGet(int delta)
    {
        for (; ; )
        {
            int current = Get();
            int next = current + delta;
            if (CompareAndSet(current, next))
                return next;
        }
    }

    public override String ToString()
    {
        return Convert.ToString(Get());
    }
}

封装过之后，直接使用AtomicInteger比使用InterLocked更方便，代码也会更直观优美！

（本文作者温少，首发于博客园，转载请注明）