一、AtomicLong的介绍
我们都知道在java中long类型变量占用的字节数是8也就是64位，而在32位的操作系统对64位的数据读写要分成两步完成，每一步取32位操作。这样的话JVM就不能保证对long和double赋值操作的原子性，因为多线程环境下有可能出现这样一种情况，两个线程同时写一个多线程共享变量(主内存)一个写低32位而另一个线程高32位或者一个线程在两步写中间过程中穿插了另一个线程的两步写操作，这样就有可能导致用户获取的64位long变量是是无效的脏数据。我们有两种方法来解决此类现象：第1种，使用volatile修饰long变量有的同学很奇怪volatile不是只保证变量多线程修改的可见性和字节码指令重排的局部有序性吗，注意java内存模型为我们保证了声明为volatile的long类型变量的赋值和获取操作是原子操作；第2种方式就是本文要讲的直接使用JUC(java.util.current包)提供的原子类AtomicLong保证长整形操作的原子性。
二、AtomicLong的数据结构
1 - 继承结构
package java.util.concurrent.atomic;
import java.util.function.LongUnaryOperator;
import java.util.function.LongBinaryOperator;
import sun.misc.Unsafe;
public class AtomicLong extends Number implements java.io.Serializable
2 - 类成员变量
private static final long serialVersionUID = 1927816293512124184L;
//Unsafe类提供了硬件级别的原子操作，通过它的compareAndSwapLong方法对long变量进行原子更新
private static final Unsafe unsafe = Unsafe.getUnsafe();
//个人理解valueOffset保存的信息类似AtomicLong内部long值的当前版本号，因为AtomicLong支持延后更新当前值不见得
//就是最新值，Unsafe进行cas操作时通过valueOffset去获取最近一次更新后的long值
private static final long valueOffset;
//标识当前JVM所在的操作系统是否支持long变量操作的原子性，其实我的理解就是判断当前操作系统是否支持对8字节也就是64
//位数据的操作原子性，再简单点就是判断该操作系统是32位的还是64位的
static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();
private static native boolean VMSupportsCS8();
static {
try {
valueOffset = unsafe.objectFieldOffset
(AtomicLong.class.getDeclaredField("value"));
} catch (Exception ex) { throw new Error(ex); }
}
//存储的long类型数据使用volatile修饰保证它修改的多线程可见性
private volatile long value;
三、AtomicLong的源码分析
1 - 构造方法
public AtomicLong(long initialValue) {
value = initialValue;
}
public AtomicLong() {
}
两个构造方法没什么可说的一个带初始值初始化value一个不带初始值（value默认初始化为0）
2 - 其他成员方法
//获取当前值
public final long get() {
return value;
}
//设置当前值为newValue，该操作是原子操作，为啥参考前面
public final void set(long newValue) {
value = newValue;
}
//延时设置当前变量为新值newValue,这个方法区别于set方法的点在于它在后台修改值且不等待修改完成立即返回，如果程序
//不需要立即获取更新后的值那么使用这个方法性能会好点
public final void lazySet(long newValue) {
unsafe.putOrderedLong(this, valueOffset, newValue);
}
//以原子操作方式更新当前值为newValue返回旧值
public final long getAndSet(long newValue) {
return unsafe.getAndSetLong(this, valueOffset, newValue);
}
//如果当前值等于预期值expect，则以原子方式基于无锁cas将当前值更新为update
public final boolean compareAndSet(long expect, long update) {
return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
}
//坑爹挂羊头卖狗肉，实现和接口定义不一致，作用和compareAndSet等同
public final boolean weakCompareAndSet(long expect, long update) {
return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
}
//以原子方式将当前值+1，返回递增之后的值
public final long getAndIncrement() {
return unsafe.getAndAddLong(this, valueOffset, 1L);
}
//以原子方法将当前值-1，返回递减之后的值
public final long getAndDecrement() {
return unsafe.getAndAddLong(this, valueOffset, -1L);
}
//以原子方式将当前值+delta返回相加前的值
public final long getAndAdd(long delta) {
return unsafe.getAndAddLong(this, valueOffset, delta);
}
//以原子方式将当前值+1，并返回递增后的值
public final long incrementAndGet() {
return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
}
//以原子方法递减并返回递减后的值
public final long decrementAndGet() {
return unsafe.getAndAddLong(this, valueOffset, -1L) - 1L;
}
//以原子方式增加指定的值delta并返回相加后的值
public final long addAndGet(long delta) {
return unsafe.getAndAddLong(this, valueOffset, delta) + delta;
}
//jdk1.8新提供的方法，应用指定函数updateFunction以原子方式更新当前值
public final long getAndUpdate(LongUnaryOperator updateFunction) {
long prev, next;
do {
prev = get();
next = updateFunction.applyAsLong(prev);
} while (!compareAndSet(prev, next));
return prev;
}
//jdk1.8新提供方法，以原子方式应用单元运算更新当前值，返回更新之后的值
public final long updateAndGet(LongUnaryOperator updateFunction) {
long prev, next;
do {
prev = get();
next = updateFunction.applyAsLong(prev);
} while (!compareAndSet(prev, next));
return next;
}
//jdk1.8新提供方法，以原子方式应用一个双元(当前值和x)运算函数完成当前值更新，返回更新前的值
public final long getAndAccumulate(long x,
LongBinaryOperator accumulatorFunction) {
long prev, next;
do {
prev = get();
next = accumulatorFunction.applyAsLong(prev, x);
} while (!compareAndSet(prev, next));
return prev;
}
//jdk1.8新提供方法，以原子方式应用一个双元(当前值和x)运算函数完成当前值更新，返回更新后的值
public final long accumulateAndGet(long x,
LongBinaryOperator accumulatorFunction) {
long prev, next;
do {
prev = get();
next = accumulatorFunction.applyAsLong(prev, x);
} while (!compareAndSet(prev, next));
return next;
}
//字符串形式
public String toString() {
return Long.toString(get());
}
//当前值转long
public int intValue() {
return (int)get();
}
//获取当前最新值，一个副作用是可以阻塞等待AtomicLong后台更新操作完成
public long longValue() {
return get();
}
//当前值转float
public float floatValue() {
return (float)get();
}
//当前值转double
public double doubleValue() {
return (double)get();
}下面我们选取incrementAndGet方法进行分析了解下AtomicLong实现long变量操作原子性的原理。
incrementAndGet方法
incrementAndGet方法以原子方式将当前值加1，返回递增后的值，下面是该方法的源码：
public final long incrementAndGet() {
return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
}分析源码可知方法内部通过调用unsafe.getAndAddLong(this,valueOffset,1L)+1L实现对long的原子加减和返回，下面我们进入Unsafe类的getAndAddLong方法源码；
public final long getAndAddLong(Object var1, long var2, long var4) {
long var6;
do {
var6 = this.getLongVolatile(var1, var2);
} while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));
return var6;
}分析这段代码我们知道，Unsafe基本就是采用循环+cas的方式保证AtomicLong的原子操作。在方法里面首先在一个循环里面根据传入的AtomicLong对象和它指定的版本号valueOffset去获取对应版本的long值，然后与当前最新版本号进行比较，如果版本号相等那么AtomicLong的value+1，返回AtomicLong更新前的volatile value，因此方法unsafe.getAndAddLong(this, valueOffset, 1L)+1就是一个volatile修饰的long类型变量+1也是原子性操作且线程安全。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
