一、简介
原子操作表示操作过程不会被中断，即使是在多线程环境下也能保证数据操作是以原子方式进行的，原子类是具有原子操作特征的类。原子类底层利用CAS、volatile和native方法来保证原子操作，从而避免synchronized的高开销，执行效率大为提升。
JUC中的原子类可以分为5类：基本类型、引用类型、数组类型、对象属性更新器和累加器。
二、基本类型
- AtomicInteger
整形原子类 - AtomicLong
长整型原子类 - AtomicBoolean
布尔型原子类
使用示例
public class AtomicDemo {
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(100);
// 以原子方式设置为给定值，返回旧值。
System.out.println(atomicInteger.getAndSet(2));
// 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值，如果成功返回true。
System.out.println(atomicInteger.compareAndSet(102,99));
// 以原子方式将给定值与当前值相加，返回新值。
System.out.println(atomicInteger.addAndGet(2));
// 以原子方式将给定值与当前值相加，返回旧值。
System.out.println(atomicInteger.getAndAdd(2));
// 以原子方式将当前值加1，返回新值。
System.out.println(atomicInteger.incrementAndGet());
// 以原子方式将当前值加1，返回旧值。
System.out.println(atomicInteger.getAndIncrement());
// 以原子方式将当前值减1，返回新值。
System.out.println(atomicInteger.decrementAndGet());
// 以原子方式将当前值减1，返回旧值。
System.out.println(atomicInteger.getAndDecrement());
}
}
三、引用类型
- AtomicReference
引用类型原子类 - AtomicStampedReference
带有整数标志的引用类型原子类 - AtomicMarkableReference
带有标记位的引用类型原子类
使用示例
public class AtomicDemo {
public static void main(String[] args) {
AtomicReference reference = new AtomicReference();
// 设置为给定值。
reference.set("the string");
System.out.println(reference);
// 返回当前值。
System.out.println(reference.get());
// 以原子方式设置为给定值，返回旧值。
System.out.println(reference.getAndSet("new string"));
// 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值，如果成功返回true。
System.out.println(reference.compareAndSet("new string","last string"));
// 带有整数标志的AtomicReference
AtomicStampedReference stampedReference = new AtomicStampedReference("the string",123456);
// 返回该引用的当前值。
System.out.println(stampedReference.getReference());
// 返回该标志的当前值。
System.out.println(stampedReference.getStamp());
// 同时设置该引用和标志的值。
stampedReference.set("new string",654321);
//如果当前引用 == 预期引用，并且当前标志等于预期标志，则以原子方式将该引用和该标志的值设置为给定的更新值，成功则返回true。
System.out.println(stampedReference.compareAndSet("new string","last string",654321,321456));
// 带有布尔标记的AtomicReference
AtomicMarkableReference markableReference = new AtomicMarkableReference("the string",true);
// 返回该引用的当前值。
System.out.println(markableReference.getReference());
// 返回该标志的当前值。
System.out.println(markableReference.getStamp());
// 同时设置该引用和标志的值。
markableReference.set("new string",false);
//如果当前引用 == 预期引用，并且当前标志等于预期标志，则以原子方式将该引用和该标志的值设置为给定的更新值，成功则返回true。
System.out.println(markableReference.compareAndSet("new string","last string",false,true));
}
}
四、数组类型
- AtomicIntegerArray
整形数组原子类 - AtomicLongArray
长整形数组原子类 - AtomicReferenceArray
引用类型数组原子类
使用示例
public class AtomicDemo {
public static void main(String[] args) {
AtomicIntegerArray integerArray = new AtomicIntegerArray(10);
// 以原子方式将索引i的元素设置为给定值，返回旧值。
System.out.println(integerArray.getAndSet(0,2));
// 如果当前值 == 预期值，则以原子方式将索引i的元素设置为给定的更新值，如果成功返回true。
System.out.println(integerArray.compareAndSet(0,2,99));
// 以原子方式将给定值与索引i的元素相加，返回新值。
System.out.println(integerArray.addAndGet(0,2));
// 以原子方式将给定值与索引i的元素相加，返回旧值。
System.out.println(integerArray.getAndAdd(0,2));
// 以原子方式将索引i的元素加1，返回新值。
System.out.println(integerArray.incrementAndGet(0));
// 以原子方式将索引i的元素加1，返回旧值。
System.out.println(integerArray.getAndIncrement(0));
// 以原子方式将索引i的元素减1，返回新值。
System.out.println(integerArray.decrementAndGet(0));
// 以原子方式将索引i的元素减1，返回旧值。
System.out.println(integerArray.getAndDecrement(0));
// 引用类型数组原子类
AtomicReferenceArray referenceArray = new AtomicReferenceArray(10);
// 以原子方式将索引i的元素设置为给定值。
referenceArray.set(0,"the string");
// 返回索引i的元素的当前值。
System.out.println(referenceArray.get(0));
// 以原子方式将索引i的元素设置为给定值，返回旧值。
System.out.println(referenceArray.getAndSet(0,"new string"));
// 如果当前值 == 预期值，则以原子方式将索引i的元素设置为给定的更新值，成功则返回true。
System.out.println(referenceArray.compareAndSet(0,"new string","last string"));
}
}
五、对象属性更新器
- AtomicIntegerFieldUpdater
以原子方式更新对象中volatile整形字段的更新器 - AtomicLongFieldUpdater
以原子方式更新对象中volatile长整形字段的更新器 - AtomicReferenceFieldUpdater
以原子方式更新对象中volatile引用类型字段的更新器。
使用示例
public class AtomicDemo {
// volatile整形字段
public volatile int num = 100;
// volatile引用类型字段
public volatile String str = "the string";
public static void main(String[] args) {
AtomicDemo demo = new AtomicDemo();
// 使用给定字段为对象创建和返回一个整形字段更新器。
AtomicIntegerFieldUpdater integerUpdater = AtomicIntegerFieldUpdater.newUpdater(AtomicDemo.class,"num");
// 以原子方式将此更新器管理的给定对象的字段设置为给定值，返回旧值。
System.out.println(integerUpdater.getAndSet(demo,2));
// 如果当前值 == 预期值，则以原子方式将此更新器管理的给定对象的字段设置为给定的更新值，如果成功返回true。
System.out.println(integerUpdater.compareAndSet(demo,102,99));
// 以原子方式将给定值与此更新器管理的给定对象的字段当前值相加，返回新值。
System.out.println(integerUpdater.addAndGet(demo,2));
// 以原子方式将给定值与此更新器管理的给定对象的字段当前值相加，返回旧值。
System.out.println(integerUpdater.getAndAdd(demo,2));
// 以原子方式将此更新器管理的给定对象的字段当前值加1，返回新值。
System.out.println(integerUpdater.incrementAndGet(demo));
// 以原子方式将此更新器管理的给定对象的字段当前值加1，返回旧值。
System.out.println(integerUpdater.getAndIncrement(demo));
// 以原子方式将此更新器管理的给定对象的字段当前值减1，返回新值。
System.out.println(integerUpdater.decrementAndGet(demo));
// 以原子方式将此更新器管理的给定对象的字段当前值减1，返回旧值。
System.out.println(integerUpdater.getAndDecrement(demo));
// 使用给定字段为对象创建和返回一个引用类型字段更新器。
AtomicReferenceFieldUpdater referenceUpdater = AtomicReferenceFieldUpdater.newUpdater(AtomicDemo.class, String.class, "str");
// 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值，如果成功返回true。
System.out.println(referenceUpdater.compareAndSet(demo,"the string","new string"));
}
}
六、累加器
java8中增加的原子类，它们使用分段的思想，把不同的线程hash到不同的段上去更新，最后再把这些段的值相加得到最终的值，这些类主要有：
- Striped64
下面四个类的父类。 - LongAccumulator
long类型的聚合器，需要传入一个long类型的二元操作，可以用来计算各种聚合操作，包括加乘等。 - LongAdder
long类型的累加器，LongAccumulator的特例，只能用来计算加法，且从0开始计算。 - DoubleAccumulator
double类型的聚合器，需要传入一个double类型的二元操作，可以用来计算各种聚合操作，包括加乘等。 - DoubleAdder
double类型的累加器，DoubleAccumulator的特例，只能用来计算加法，且从0开始计算。
使用示例
public class AtomicDemo {
public static void main(String[] args) {
// 构造累加器
LongAdder adder = new LongAdder();
// 加上123
adder.add(123L);
// 加1
adder.increment();
// 减1
adder.decrement();
// 求和
adder.sum()();
// 重置
adder.reset();
// 构造累加器，指定自定义二元运算函数和初始值
LongAccumulator accumulator = new LongAccumulator((a,b)-> a + b, 0);
// 增加给定值
accumulator.accumulate(5);
// 返回当前值
accumulator.get();
// 重置累加器
accumulator.reset();
}
}