AtomicLong、AtomicLongArray、AtomicLongFieldUpdater 深入源码解析

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

  本篇主要对AtomicLong、AtomicLongArray、AtomicLongFieldUpdater进行讲解，本博已经对AtomicInteger、AtomicIntegerArray、AtomicIntegerFieldUpdater源码进行了深入解析。其实这几个类原理都是类似的，不同的是针对的操作数据类型有差异。

  演示示例：

  可以参考《AtomicBoolean 完全源码解析》、《AtomicInteger 完全源码解析》、《AtomicIntegerArray 深入源码解析》、《AtomicIntegerFieldUpdater 深入源码解析》序列文章。

  首先，新建一个Thread类，用于模拟多线程环境：

package com.securitit.serialize.atomics;import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicLongArray;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;public class AtomicLongThread extends Thread {// AtomicLong实例.private AtomicLong atomicLong;// AtomicLongArray实例.private AtomicLongArray atomicLongArray;// AtomicLongFieldUpdater实例.private AtomicLongFieldUpdater<AtomicLongFieldUpdaterBean> atomicLongFieldUpdater;// AtomicLongFieldUpdaterBean实例.private AtomicLongFieldUpdaterBean atomicLongFieldUpdaterBean;// CountDownLatch可以进行线程计数，到达指定计数时，可唤醒调用await方法的线程.private CountDownLatch countDownLatch;public AtomicLongThread(AtomicLong atomicLong, AtomicLongArray atomicLongArray,AtomicLongFieldUpdater<AtomicLongFieldUpdaterBean> atomicLongFieldUpdater,AtomicLongFieldUpdaterBean atomicLongFieldUpdaterBean, CountDownLatch countDownLatch) {this.atomicLong = atomicLong;this.atomicLongArray = atomicLongArray;this.atomicLongFieldUpdater = atomicLongFieldUpdater;this.atomicLongFieldUpdaterBean = atomicLongFieldUpdaterBean;this.countDownLatch = countDownLatch;}@Overridepublic void run() {// 对AtomicLong变量进行累加.atomicLong.incrementAndGet();// 对AtomicLongArray指定索引位置的值进行累加.for (int index = 0; index < atomicLongArray.length(); index++) {atomicLongArray.incrementAndGet(index);}// 对AtomicLongFieldUpdater实例变量进行累加.if(atomicLongFieldUpdater.compareAndSet(atomicLongFieldUpdaterBean, 100L, 200L)) {System.out.println("AtomicLongFieldUpdater 更新成功.");} else {System.out.println("AtomicLongFieldUpdater 更新失败.");}countDownLatch.countDown();}}

  然后，为AtomicLongFieldUpdater测试新建Bean类，类中只包含一个counter属性：

package com.securitit.serialize.atomics;public class AtomicLongFieldUpdaterBean {// 内部计数器.public volatile long counter = 100;public long getCounter() {return counter;}public void setCounter(long counter) {this.counter = counter;}}

  最后，是测试类，在开启多线程操作AtomicLong、AtomicLongArray、AtomicArrayFieldUpdater，以模拟多线程环境：

package com.securitit.serialize.atomics;import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicLongArray;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;public class AtomicLongTester {// AtomicLong实例.private static AtomicLong atomicLong;// AtomicLongArray实例.private static AtomicLongArray atomicLongArray;// AtomicLongFieldUpdater实例.private static AtomicLongFieldUpdater<AtomicLongFieldUpdaterBean> atomicLongFieldUpdater;// AtomicLongFieldUpdaterBean实例.private static AtomicLongFieldUpdaterBean atomicLongFieldUpdaterBean;// CountDownLatch可以进行线程计数，到达指定计数时，可唤醒调用await方法的线程.private static CountDownLatch countDownLatch = new CountDownLatch(4);public static void main(String[] args) throws Exception {// 初始化AtomicLong实例.atomicLong = new AtomicLong(100L);// 初始化AtomicLongArray实例.atomicLongArray = new AtomicLongArray(10);// 初始化AtomicLongArray实例数组内部值.for (int index = 0; index < atomicLongArray.length(); index++) {// 用当前索引作为值.atomicLongArray.set(index, index);}// 初始化AtomicLongFieldUpdater实例.atomicLongFieldUpdater = AtomicLongFieldUpdater.newUpdater(AtomicLongFieldUpdaterBean.class, "counter");// 初始化AtomicLongFieldUpdaterBean实例.atomicLongFieldUpdaterBean = new AtomicLongFieldUpdaterBean();atomicLongFieldUpdaterBean.setCounter(100L);// 启动多线程测试.new AtomicLongThread(atomicLong, atomicLongArray, atomicLongFieldUpdater, atomicLongFieldUpdaterBean,countDownLatch).start();new AtomicLongThread(atomicLong, atomicLongArray, atomicLongFieldUpdater, atomicLongFieldUpdaterBean,countDownLatch).start();new AtomicLongThread(atomicLong, atomicLongArray, atomicLongFieldUpdater, atomicLongFieldUpdaterBean,countDownLatch).start();new AtomicLongThread(atomicLong, atomicLongArray, atomicLongFieldUpdater, atomicLongFieldUpdaterBean,countDownLatch).start();// 等待所有线程执行完毕.countDownLatch.await();// 输出AtomicLong的值.System.out.println("AtomicLong：" + atomicLong.get());// 输出AtomicLongArray数值.for (int index = 0; index < atomicLongArray.length(); index++) {if (atomicLongArray.get(index) != index + 4) {System.out.println("数据计算出现问题.");}}}}

  输出结果：

AtomicLongFieldUpdater 更新失败.
AtomicLongFieldUpdater 更新成功.
AtomicLongFieldUpdater 更新失败.
AtomicLongFieldUpdater 更新失败.
AtomicLong：104

  从结果可以看出：

  · AtomicLong在4个线程中被正确增加到4。

  · AtomicLongArray未打印异常日志，说明已更新成功，若想确认，可以将atomicLongArray每一项打印出来确认。

  · AtomicLongFieldUpdater在4个线程中，只有一个线程将值由100L修改为200L，其他线程执行CAS过程中，compare失败。

  源码分析：

  实现基础：

  AtomicLong：

// long类型内存偏移位置.
private static final long valueOffset;
// 记录VM是否支持长整型的无锁CAS操作.
// 虽然Unsafe类的compareAndSwapLong方法在两种情况下均有效.
static final boolean VM_SUPPORTS_LONG_CAS = VMSupportsCS8();
// 数据存储变量.
private volatile long value;

  AtomicLongArray：

// 表示内存中int[]的初始地址.
private static final int base = unsafe.arrayBaseOffset(long[].class);
// int[]数组中元素位移个数.
private static final int shift;
// 用来存储真实int[]数组的变量.
private final long[] array;

  AtomicLongFieldUpdater：

public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName){Class<?> caller = Reflection.getCallerClass();if (AtomicLong.VM_SUPPORTS_LONG_CAS)return new CASUpdater<U>(tclass, fieldName, caller);elsereturn new LockedUpdater<U>(tclass, fieldName, caller);
}

  AtomicLongFieldUpdater是一个abstract类，内置了两个静态内部类：CASUpdater和LockedUpdater，若VM支持long类型的CAS操作，则使用CASUpdater进行数据操作；若VM不支持long类型的CAS操作，则使用LockedUpdater（即synchronized）进行数据操作，保证多线程环境下数据安全性。

  基本方法：

  AtomicLong：

// 获取long的值.
public final long get();
// 设置long的值.
public final void set(long newValue);
// 延迟设置long的值.
public final void lazySet(long newValue);
// 先取值，再修改.
public final long getAndSet(long newValue);
// 依赖CAS，进行赋值操作.
public final boolean compareAndSet(long expect, long update);
// 依赖CAS，进行赋值操作.
public final boolean weakCompareAndSet(long expect, long update);
// 先取值，再自增.
public final long getAndIncrement();
// 先取值，再自减.
public final long getAndDecrement();
// 先取值，再原值加上delta.
public final long getAndAdd(long delta);
// 先自增，再取值.  
public final long incrementAndGet();
// 先自减，再取值.
public final long decrementAndGet();
// 先原值加上delta，再取值.
public final long addAndGet(long delta);
// 先取值，再修改当前原值.
public final long getAndUpdate(LongUnaryOperator updateFunction);
// 先修当前原值，再取值.
public final long updateAndGet(LongUnaryOperator updateFunction);
// 使用LongBinaryOperator对当前值和第一个参数进行计算，并更新当前值.
public final long getAndAccumulate(long x, LongBinaryOperator accumulatorFunction);
// 使用LongBinaryOperator对当前值和第一个参数进行计算，并更新当前值.
public final long accumulateAndGet(long x, LongBinaryOperator accumulatorFunction);
// 按int类型取值.
public int intValue();
// 按long类型取值.
public long longValue();
// 按float类型取值.
public float floatValue();
// 按double类型取值.
public double doubleValue();

  AtomicLongArray：

// 数组内容长度.
public final int length();
// 取得指定索引位置的值.
public final long get(int i);
// 设置指定索引位置的值.
public final void set(int i, long newValue);
// 延迟设置指定索引位置的值.
public final void lazySet(int i, long newValue);
// 先取值，再修改.
public final long getAndSet(int i, long newValue);
// 依赖CAS，进行比较替换.
public final boolean compareAndSet(int i, long expect, long update);
// 依赖CAS，进行比较替换.
public final boolean weakCompareAndSet(int i, long expect, long update);
// 先取值，再自增.
public final long getAndIncrement(int i);
// 先取值，再自减.
public final long getAndDecrement(int i);
// 先取值，原值加上delta.
public final long getAndAdd(int i, long delta);
// 先自增，再取值.
public final long incrementAndGet(int i);
// 先自减，再取值.
public final long decrementAndGet(int i);
// 先原值加delta，再取值.
public long addAndGet(int i, long delta);
// 先取值，再修改当前原值.
public final long getAndUpdate(int i, LongUnaryOperator updateFunction);
// 先修当前原值，再取值.
public final long updateAndGet(int i, LongUnaryOperator updateFunction);
// 使用LongBinaryOperator对当前值和第一个参数进行计算，并更新当前值.
public final long getAndAccumulate(int i, long x, LongBinaryOperator accumulatorFunction);
// 使用LongBinaryOperator对当前值和第一个参数进行计算，并更新当前值.
public final long accumulateAndGet(int i, long x, LongBinaryOperator accumulatorFunction);

  AtomicLongFieldUpdater：

// 依赖CAS，进行比较替换.
public abstract boolean compareAndSet(T obj, long expect, long update);
// 依赖CAS，进行比较替换.
public abstract boolean weakCompareAndSet(T obj, long expect, long update);
// 设置值.
public abstract void set(T obj, long newValue);
// 延迟设置值.
public abstract void lazySet(T obj, long newValue);
// 取值.
public abstract long get(T obj);
// 先取值，再修改.
public long getAndSet(T obj, long newValue);
// 先取值，再自增.
public long getAndIncrement(T obj);
// 先取值，再自减.
public long getAndDecrement(T obj);
// 先取值，再原值加上delta.
public long getAndAdd(T obj, long delta);
// 先自增，再取值.
public long incrementAndGet(T obj);
// 先自减，再取值.
public long decrementAndGet(T obj);
// 先原值加上delta，再取值.
public long addAndGet(T obj, long delta);
// 先取值，再修改当前原值.
public final long getAndUpdate(T obj, LongUnaryOperator updateFunction);
// 先修当前原值，再取值.
public final long updateAndGet(T obj, LongUnaryOperator updateFunction);
// 使用LongBinaryOperator对当前值和第一个参数进行计算，并更新当前值.
public final long getAndAccumulate(T obj, long x, LongBinaryOperator accumulatorFunction);
// 使用LongBinaryOperator对当前值和第一个参数进行计算，并更新当前值.
public final long accumulateAndGet(T obj, long x, LongBinaryOperator accumulatorFunction);

  AtomicLong、AtomicLongArray、AtomicLongFieldUpdater使用方式与AtomicInteger、AtomicIntegerArray、AtomicIntegerFieldUpdater基本保持一致，只要搞清楚其中一种类的操作方式，另一个也可以一样使用。

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

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

这篇关于AtomicLong、AtomicLongArray、AtomicLongFieldUpdater 深入源码解析的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---