AtomicInteger 完全源码解析

本文主要是介绍AtomicInteger 完全源码解析，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

AtomicInteger可以用于原子的更新int变量的值，但不可用于替换java.lang.Integer。同时，AtomicInteger集成了Number类型，允许统一访问基于Number类的工具类和程序代码。

AtomicInteger依赖CAS原始实现，在多线程环境下，能保证AtomicInteger所包装的int原子的进行加减操作。

普通int加减：

在无锁环境下，针对int的复合操作是无法保证原子性的。在多线程环境下，非原子性操作是会发生错乱，导致产生非预期的结果。

演示示例：

package com.securitit.serialize.atomics;import java.util.concurrent.CountDownLatch;public class IntTester {// 初始化int值.public static int count = 0;// 初始化volatile int值.public static volatile int volatileCount = 0;// 定义CountDownLatch，可以截停指定数量线程，并统一唤醒.public static CountDownLatch countDownLatch = new CountDownLatch(2);// 对int、volatile int自增操作.public static void increase() {count++;volatileCount++;}// 主类入口测试类.public static void main(String[] args) throws InterruptedException {Thread[] threads = new Thread[2];for (int i = 0; i < threads.length; i++) {threads[i] = new Thread(() -> {// 对数据进行1000次自增操作.for (int i1 = 0; i1 < 1000; i1++) {increase();}countDownLatch.countDown();});threads[i].start();}// 等待两个线程一起执行.countDownLatch.await();// 输出自增结果.System.out.println(count);System.out.println(volatileCount);}}

运行结果：

1994
1988

上面这段程序的期望结果是2000，但是普通int类型以及volatile int类型都未能如愿输出期望值。这就要从i++的底层实现方式讲起，i++是一种编译语法糖，i++经过编译后，由三个操作组成，这样就导致多线程时，这三个操作的执行顺序不固定，存在中间变量共享读取、共享修改等问题。

正是由于以上缘故，AtomicInteger为了解决这类问题诞生了，AtomicInteger使用volatile和CAS等保证int类型数据自增、自减等操作的多线程安全性以及正确性。

演示示例：

package com.securitit.serialize.atomics;import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;public class AtomicIntegerTester {private static final int THREADS_COUNT = 2;// 初始化AtomicInteger值.public static AtomicInteger atomicIntegerCount = new AtomicInteger(0);// 定义CountDownLatch，可以截停指定数量线程，并统一唤醒.public static CountDownLatch countDownLatch = new CountDownLatch(2);/*** 对AtomicInteger自增操作.*/public static void increase() {atomicIntegerCount.incrementAndGet();}public static void main(String[] args) throws InterruptedException {Thread[] threads = new Thread[THREADS_COUNT];for (int i = 0; i < threads.length; i++) {threads[i] = new Thread(() -> {// 对数据进行1000次自增操作.for (int i1 = 0; i1 < 1000; i1++) {increase();}countDownLatch.countDown();});threads[i].start();}// 等待两个线程一起执行.countDownLatch.await();// 输出自增结果.System.out.println(atomicIntegerCount.get());}}

输出结果：

以上的代码，无论运行多少次，直接结果都正符合我们预期的值。

源码分析：

同样让我们分析一下AtomicBoolean类中的API。

实现基础：

private volatile int value;

和其他AtomicXXXXX类似，AtomicInteger也是通过volatile类型变量在内部记录实际的int类型值。具体volatile的特性以及内存实现方式，可以参照本博介绍volatile的文章。volatile能保证单一赋值操作的原子性。

构造方法：

public AtomicInteger();
public AtomicInteger(int initialValue);

AtomicInteger提供了两种构造方法，无参构造方法内无实现，初始值取决于成员变量value的初始值，由于是int类型，初始值为0。一个参数构造方法，传入参数作为初始值。

取值/赋值：

// 直接取值，直接获取类私有volatile变量.
public final int get();
// 直接赋值，直接赋值给类私有volatile变量.
public final void set(int newValue);
// AtomicInteger操作都是依赖volatile int变量来实现，
// volatile关键字保证了int类型变量在多个线程中的可见性，
// lazySet的作用就是抵消这种保证，让volatile int变量可以如普通变量一样操作，
// 在多线程环境中，恢复可见性问题。
public final void lazySet(int newValue);

AtomicInteger提供了get/set用于进行普通赋值操作，这三个操作在多线程环境下，由于不具备CAS处理功能，所以可能导致意想不到的问题。

CAS取值/赋值：

// 先取值，再进行赋值操作.
public final int getAndSet(int newValue);
// 先取值，再进行赋值操作.
public final int getAndAdd(int delta)
// 先赋值，再获取变量的值.
public final int addAndGet(int delta);
// 先取值，再修改变量的值.
public final int getAndUpdate(IntUnaryOperator updateFunction);
// 先修改变量的值，再取值.
public final int updateAndGet(IntUnaryOperator updateFunction);
// 使用IntBinaryOperator对当前值和第一个参数进行计算，并更新当前值.
public final int getAndAccumulate(int x,IntBinaryOperator accumulatorFunction);
// 使用IntBinaryOperator对当前值和第一个参数进行计算，并更新当前值.
public final int accumulateAndGet(int x,IntBinaryOperator accumulatorFunction);
// 依赖CAS，进行比较再替换.
public final boolean compareAndSet(int expect, int update);
// 依赖CAS，进行比较再替换.
public final boolean weakCompareAndSet(int expect, int update);
// 先取值，再自增.类似i++;
public final int getAndIncrement();
// 先取值，再自减.类似i--;
public final int getAndDecrement();
// 先自增，再取值.类似++i;
public final int incrementAndGet();
// 先自减，再取值.类似--i;
public final int decrementAndGet();

这些方法都是利用Unsafe类的CAS进行操作的实现，都是基于无锁实现，就不一一介绍了。要说明的一点是：weakCompareAndSet的使用。

官方文档注释：以原子的方式更新这个更新器所管理的对象(obj)的成员变量，并且将这个成员变量更新为给定的更新后的值(update)如果当前值等于期望值(expect)时，当存在其他使用compareAndSet或者set的情况下，这个方法可以确保是原子的，但如果你用其他的方式去改变这个成员变量时(如，使用直接赋值的方式 field=newField)，那么它是不会遵循这个原子性的。该方法可能可能虚假的失败并且不会提供一个排序的保证，所以它在极少的情况下用于代替compareAndSet方法。

个人来看，weakCompareAndSet和compareAndSet至少在JDK1.8版本及之前，没有明显差别，两个方法的唯一差别只是weakCompareAndSet没有final修饰，所以不同厂商的虚拟机可以对其进行改造，根据自身指令级确定CAS实现，也就是不确定性的由来。

按类型取值：

// 取int类型值.
public int intValue();
// 取long类型值.
public long longValue();
// 取float类型值.
public float floatValue();
// 去double类型值.
public double doubleValue();