AtomicInteger

AtomicInteger、AtomicLong、AtomicBoolean、AtomicReference等都大同小异。

// ~add
// ===========================================
int incrementAndGet()
线程安全版本的++i操作。

int getAndIncrement()
线程安全版本的i++操作。

// ~minus
// ===========================================
int decrementAndGet()
线程安全版本的--i操作。

int getAndDecrement()
线程安全版本的i--操作。

// ~add && minus
// ===========================================
int addAndGet(int delta)
线程安全版本的 i=i+delta; return i;操作。

int getAndAdd(int delta)
线程安全版本的t=i; i+=delta; return t;操作。

// ~get && set
// ===========================================
int get()
获取当前值。

void set(int newValue)
设置为给定值。

void lazySet(int newValue)
延时设置变量值。

int getAndSet(int newValue)
设置新值，返回旧值。线程安全版本的t=i; i=newValue; return t;操作。

boolean compareAndSet(int expect, int update)
你所期望的当前值与真实当前值相同，则更新值。

boolean weakCompareAndSet(int expect, int update)
调用weakCompareAndSet时并不能保证不存在happen-before的发生（也就是可能存在指令重排序导致此操作失败）。但是从Java源码来看，其实此方法并没有实现JSR规范的要求，最后效果和compareAndSet是等效的，都调用了unsafe.compareAndSwapInt()完成操作。

示例

final AtomicInteger value = new AtomicInteger(10);
//如果当前值(10)与我期望的当前值(1)相同，修改成功返回true，否则修改失败false
Assert.assertEquals(value.compareAndSet(1,2),false);
//当前值10
Assert.assertEquals(value.get(), 10);
//如果当前值(10)与我期望的当前值(10)相同，修改成功返回true，否则修改失败false
Assert.assertEquals(value.compareAndSet(10,3),true);
//当前值3
Assert.assertEquals(value.get(), 3);


//设置为0
value.set(0);
//++i，为1
Assert.assertEquals(value.incrementAndGet(),1);
//t=i; i+=2; return t;
Assert.assertEquals(value.getAndAdd(2),1);
//上一次结果为3，先return 3然后设置为5
Assert.assertEquals(value.getAndSet(5),3);
//现在值为5
Assert.assertEquals(value.get(),5);


//多线程下
Thread[] ts = new Thread[10];
for (int i = 0; i < 10; i++) {
   ts[i] = new Thread() {
      @Override
      public void run() {
         value.incrementAndGet();
      }
   };
}
//并行执行，主线程要等每个子线程执行完才能结束
for (Thread t : ts) {t.start();}
for (Thread t : ts) {t.join();}
Assert.assertEquals(value.get(),5+10);

AtomicIntegerArray

AtomicIntegerArray/AtomicLongArray/AtomicReferenceArray类似。

示例

AtomicIntegerArray array = new AtomicIntegerArray(new int[10]);
array.set(2,10);
System.out.println(array.get(2));

AtomicIntegerFieldUpdater

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

API使用约束

字段必须是volatile类型的。

只能修改可见范围的（比如private的就不可以）

只能是实例变量，不能是类变量。

示例

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;

public class AtomicIntegerFieldUpdaterDemo {

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


    void doit() {
        DemoData data = new DemoData();

        int value1 = AtomicIntegerFieldUpdater
                .newUpdater(DemoData.class, "value1")
                .getAndSet(data ,10);
        System.out.println("1 ==> " + value1);

        int value2 = AtomicIntegerFieldUpdater
                .newUpdater(DemoData.class, "value2")
                .incrementAndGet(data);
        System.out.println("3 ==> " + value2);

        int value3 = AtomicIntegerFieldUpdater
                .newUpdater(DemoData.class, "value3")
                .decrementAndGet(data);
        System.out.println("2 ==> " + value3);

        boolean value4 = AtomicIntegerFieldUpdater
                .newUpdater(DemoData.class, "value4")
                .compareAndSet(data,4,5);
        System.out.println("true ==> " + value4);
    }

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

结果: 
value3、value4不能修改到。会报错，不明白为什么默认的都能访问到，但是protected字段的却不行

AtomicStampedReference

先看看Atomic的ABA问题: 假设低于20元，赠送20元刺激消费。可是一个人消费之后又低于20元，这样就会不断的赠送。

示例

static AtomicStampedReference<Integer> money = new AtomicStampedReference<>(19,0);

LongAdder与AtomicLong

AtomicLong: 需要精确的数值的时候使用AtomicLong
LongAdder: LongAdder在并发情况下数据可能有些误差, 高并发、不需要精确数据使用LongAdder。

J.U.C Atomic