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();

总结：

AtomicInteger提供了针对int在多线程环境下无法正确运行的解决方案，AtomicInteger实现的根基包括：volatile和CAS。

注：文中源码均来自于JDK1.8版本，不同版本间可能存在差异。

如果有哪里有不明白或不清楚的内容，欢迎留言哦！

AtomicInteger 完全源码解析

猜你喜欢