Atomic类

简单的、高效的、线程安全的递增递减方案；
以java.util.concurrent.atomic.AtomicInteger为例：

int addAndGet(int delta)
以原子方式将给定值与当前值相加。 实际上就是等于线程安全版本的i =i+delta操作。

boolean compareAndSet(int expect, int update)
如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。 如果成功就返回true，否则返回false，并且不修改原值。

int decrementAndGet()
以原子方式将当前值减 1。 相当于线程安全版本的--i操作。

int get()
获取当前值，值被synchronized修饰

int getAndAdd(int delta)
以原子方式将给定值与当前值相加。 相当于线程安全版本的t=i;i+=delta;return t;操作。

int getAndDecrement()
以原子方式将当前值减 1。 相当于线程安全版本的i--操作。

int getAndIncrement()
以原子方式将当前值加 1。 相当于线程安全版本的i++操作。

int getAndSet(int newValue)
以原子方式设置为给定值，并返回旧值。 相当于线程安全版本的t=i;i=newValue;return t;操作。

int incrementAndGet()
以原子方式将当前值加 1。 相当于线程安全版本的++i操作。

void lazySet(int newValue)
最后设置为给定值。 延时设置变量值，这个等价于set()方法，但是由于字段是volatile类型的，因此次字段的修改会比普通字段（非volatile字段）有稍微的性能延时（尽管可以忽略），所以如果不是想立即读取设置的新值，允许在“后台”修改值，那么此方法就很有用。如果还是难以理解，这里就类似于启动一个后台线程如执行修改新值的任务，原线程就不等待修改结果立即返回（这种解释其实是不正确的，但是可以这么理解）。

void set(int newValue)
设置为给定值。 直接修改原始值，也就是i=newValue操作。

boolean weakCompareAndSet(int expect, int update)
如果当前值 == 预期值，则以原子方式将该设置为给定的更新值。JSR规范中说：以原子方式读取和有条件地写入变量但不 创建任何 happen-before 排序，因此不提供与除 weakCompareAndSet 目标外任何变量以前或后续读取或写入操作有关的任何保证。大意就是说调用weakCompareAndSet时并不能保证不存在happen-before的发生（也就是可能存在指令重排序导致此操作失败）。但是从Java源码来看，其实此方法并没有实现JSR规范的要求，最后效果和compareAndSet是等效的，都调用了unsafe.compareAndSwapInt()完成操作。

AtomicInteger和AtomicLong、AtomicBoolean、AtomicReference方法类似

AtomicIntegerArray/AtomicLongArray/AtomicReferenceArray的API类似；数组下标的原子性递增递减操作；

AtomicIntegerArray：

void set(int i, int newValue)
void lazySet(int i, int newValue)
int getAndSet(int i, int newValue)
boolean compareAndSet(int i, int expect, int update)
boolean weakCompareAndSet(int i, int expect, int update)
int getAndIncrement(int i)
int getAndDecrement(int i)
int getAndAdd(int i, int delta)
int incrementAndGet(int i)
int decrementAndGet(int i)
int addAndGet(int i, int delta)
从名字就能看出用途；

AtomicIntegerFieldUpdater<T>/AtomicLongFieldUpdater<T>/AtomicReferenceFieldUpdater<T,V>是基于反射的原子更新字段的值。
相应的API也是非常简单的，但是也是有一些约束的。

（1）字段必须是volatile类型的！

（2）字段的描述类型（修饰符public/protected/default/private）是与调用者与操作对象字段的关系一致。也就是说调用者能够直接操作对象字段，那么就可以反射进行原子操作。但是对于父类的字段，子类是不能直接操作的，尽管子类可以访问父类的字段。因为是反射，比如private就无法从外部访问到

（3）只能是实例变量，不能是类变量，也就是说不能加static关键字。

（4）只能是可修改变量，不能使final变量，因为final的语义就是不可修改。实际上final的语义和volatile是有冲突的，这两个关键字不能同时存在。

（5）对于AtomicIntegerFieldUpdater和AtomicLongFieldUpdater只能修改int/long类型的字段，不能修改其包装类型（Integer/Long）。如果要修改包装类型就需要使用AtomicReferenceFieldUpdater。

public class AtomicIntegerFieldUpdaterDemo {

    class DemoData{
        public volatile int value1 = 1;
        volatile int value2 = 2;
        private volatile int value4 = 4;
    }

    AtomicIntegerFieldUpdater<DemoData> getUpdate(String fieldName){
        return AtomicIntegerFieldUpdater.newUpdater(DemoData.class, fieldName);
    }

    void doit(){
        DemoData demoData = new DemoData();
        System.out.println("1==>" + getUpdate("value1").getAndSet(demoData, 10));
        System.out.println("3==>" + getUpdate("value2").incrementAndGet(demoData));
        //这里抛异常，private是无法外部访问到的
        System.out.println("true==>" + getUpdate("value4").compareAndSet(demoData, 4, 5));
    }

    public static void main(String[] args) {
        AtomicIntegerFieldUpdaterDemo demo = new AtomicIntegerFieldUpdaterDemo();
        demo.doit();
    }
}

AtomicMarkableReference/AtomicStampedReference
待续

参考

深入浅出 Java Concurrency (3): 原子操作 part 2