AtomicInteger类位于concurrent.atomic包下，它的主要用来支持对int或Integer类型进行的原子操作。原子操作可以保证线程安全性，因此，AtomicInteger类也常常用来做线程安全计数器，他的作用是int和Integer不可替代的。
原子操作指一个操作不可被分割，也不可被重排序，执行的结果要么成功要么失败。这里的操作可以是一条或多条指令。
AtomicInteger类也继承了Number类。Number类是一个抽象类，也是所有可以转换成基础类型的数值型类的父类。他的主要作用是对数值型数据类型转换进行规范。
public class AtomicInteger extends Number implements java.io.Serializable
所在路径：\java\util\concurrent\atomic\AtomicInteger.java
一、成员变量
首先是常规成员变量，包括序列化id和value等。需要注意的是，这里的value属性是被volatile关键字修饰的，这是多线程临界资源定义的一种常规手法，表明该属性具有对多个线程的可见性并被禁止指令重排序。
/** serialVersionUID */
private static final long serialVersionUID = 6214790243416807050L;
/** 存储对象值 */
private volatile int value;
/** 存储对象在内存中的偏移量 */
private static final long valueOffset;
在当前的 Java 内存模型下，线程可以把变量保存到本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。
要解决这个问题，就需要把变量声明为volatile，这就指示 JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。
除了常规成员变量，AtomicInteger类还定义了一个Unsafe类型变量以对直接内存进行操作。Unsafe类位于sun.misc包下，用来操作直接内存，它提供的方法多数是native的。
// setup to use Unsafe.compareAndSwapInt for updates
private static final Unsafe unsafe = Unsafe.getUnsafe();
此外，AtomicInteger类定义了一个静态代码块，用来获取value属性在内存中的偏移量。
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicInteger.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
静态代码块随着类的加载而执行，且只执行一次，它的原理和static关键字是类似的。一个类中代码块的执行顺序为：静态代码块 -> 构造代码块 -> 构造函数
二、构造器
AtomicInteger的构造器比较简单，直接使用默认构造器获得一个为0或value初始值，或者通过参数给它赋值。
public AtomicInteger() {
}
public AtomicInteger(int initialValue) {
value = initialValue;
}
三、set()和lazySet()
想要在初始化完成后对value进行赋值，就需要使用set()方法。AtomicInteger提供了两种set方式。
1、set()
set()方法可以完成一次直接赋值。
public final void set(int newValue) {
value = newValue;
}
2、lazySet()
lazySet()方法实现了对value的非volatile赋值，通过调用unsafe.putOrderedInt()方法，直接向固定偏移量的内存上写入数据，但不使其对其他线程立刻可见（putOrderedInt()是putIntVolatile()的延迟实现）。
public final void lazySet(int newValue) {
unsafe.putOrderedInt(this, valueOffset, newValue);
}
lazySet()方法存在的意义是在某些不需要volatile的场景下，通过延迟赋值提高程序运行的效率。这个方法很少被上层调用者使用。
lazySet()方法：https://blog.csdn.net/bluetjs/article/details/52423867
四、get()
想要获取value的值就需要使用get()方法，AtomicInteger除了提供基本的get()方法之外，还提供了getAndSet()，getAndIncrement()，getAndDecrement()，getAndAdd()，getAndUpdate()和getAndAccumulate()等方法。
1、get()
public final int get() {
return value;
}
2、getAndSet()
getAndSet()方法实际上调用getAndSetInt()方法，它的底层实现逻辑是利用getIntVolatile()方法获取value后进行的自旋CAS操作。
public final int getAndSet(int newValue) {
return unsafe.getAndSetInt(this, valueOffset, newValue);
}
其中unsafe.getAndSetInt()方法的源码如下所示，这两个方法都是native方法。
public final int getAndSetInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var4));
return var5;
}
3、getAndIncrement()，getAndDecrement()和getAndAdd()
这两个方法实现的原理和getAndSet()方法基本是一样的，只是将get出来的value加1或减1了而已。
/** 自增就是加1，返回自增前的值 */
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
}
/** 自减就是减1，返回自增前的值 */
public final int getAndDecrement() {
return unsafe.getAndAddInt(this, valueOffset, -1);
}
/** Add操作就是可以自定义增加的值 */
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
}
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
/** 自增的同时返回自增后的值 */
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
/** 自减的同时返回自减后的值 */
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
}
4、getAndUpdate()和getAndAccumulate()
getAndUpdate()和getAndAccumulate()分别以函数式编程接口IntUnaryOperator和IntBinaryOperator为入参，实现AtomicInteger的自定义变换。用户可以自定义一个函数，让value按函数计算结果递增，也可以定义两个可以互相翻转的int，使value交替变换。
public final int getAndUpdate(IntUnaryOperator updateFunction) {
int prev, next;
do {
prev = get();
next = updateFunction.applyAsInt(prev);
} while (!compareAndSet(prev, next));
return prev;
}
public final int getAndAccumulate(int x,
IntBinaryOperator accumulatorFunction) {
int prev, next;
do {
prev = get();
next = accumulatorFunction.applyAsInt(prev, x);
} while (!compareAndSet(prev, next));
return prev;
}
可以看到，两个方法的核心都是compareAndSet()，它的源码为：
/**
* 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 {@code 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);
}
与之相对的是weakCompareAndSet()方法，它是一个少数情况下compareAndSet()方法的替代。JDK8及以前，这两个方法的实现代码完全一样，而在JDK9之后，weakCompareAndSet()方法增加了@HotSpotIntrinsicCandidate注解。
/**
* Atomically sets the value to the given updated value
* if the current value {@code ==} the expected value.
*
* <p><a href="package-summary.html#weakCompareAndSet">May fail
* spuriously and does not provide ordering guarantees</a>, so is
* only rarely an appropriate alternative to {@code compareAndSet}.
*
* @param expect the expected value
* @param update the new value
* @return {@code true} if successful
*/
public final boolean weakCompareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}e); }
这两个方法的具体区别我还没有搞清楚，只能先给大家两个参考链接了，虽然我个人认为第一个链接里讲的未必正确...
weakCompareAndSet：https://www.jianshu.com/p/55a66113bc54
happens-before：https://www.jianshu.com/p/9464bf340234
@HotSpotIntrinsicCandidate：https://blog.csdn.net/a772304419/article/details/100121143
五、其他
1、toString()
public String toString() {
return Integer.toString(get());
}
2、其他继承自Number类的方法
public int intValue() {
return get();
}
public long longValue() {
return (long)get();
}
public float floatValue() {
return (float)get();
}
public double doubleValue() {
return (double)get();
}
