1、数组类型的原子类     

原子数组类型，这个其实和AtomicInteger等类似，只不过在修改时需要指明数组下标。

CAS是按照==来根据地址进行比较。数组比较地址，肯定是不行的，只能比较下标元素。而比较下标元素，就和元素的类型有关系了。

在java.util.concurrent.atomic中，原子类型数组有以下四种：

类名	说明
AtomicIntegerArray	提供对int[]数组元素的原子性更新操作
AtomicLongArray	提供对long[]数组元素的原子性更新操作
AtomicReferenceArray	提供对引用类型[]数组元素的原子性更新操作
AtomicBooleanArray	原子更新布尔类型数组的元素

使用原子的方式更新数组里的某个元素。 

2、常用方法

        AtomicIntegerArray和AtomicLongArray的使用方式差别不大，AtomicReferenceArray因为他的参数为引用数组，所以跟前两个的使用方式有所不同。AtomicBooleanArray在生产中使用的很少。

本次只对AtomicLongArray和AtomicReferenceArray方法进行详细的介绍。

2.1、AtomicLongArray介绍

2.1.1、构造方法

方法名	说明
AtomicLongArray(int length)	创建给定长度的新 AtomicLongArray
AtomicLongArray(long[] array)	创建与给定数组具有相同长度的新 AtomicLongArray，并从给定数组复制其所有元素

2.1.2、方法

方法	说明
long getAndIncrement(int i)	以原子方式将索引 i 的元素自增 1，并返回旧值
long incrementAndGet(int i)	以原子方式将索引 i 的元素自增 1，并返回减少之后的值
long getAndDecrement(int i)	以原子形式将索引i处的元素原子自减1，并返回旧值
long decrementAndGet(int i)	以原子形式将索引i处的元素原子自减1，并返回减少之后的值
long addAndGet(int i, long delta)	以原子形式将给定元素与数组中索引i的元素相加
long getAndSet(int i, long newValue)	将地位i处的元素原子设置为给定值，并返回旧值
long get(int i)	获取位置 i 的当前值
void lazySet(int i, long newValue)	最终将位置 i 的元素设置为给定值
int length()	返回数组的长度
void set(int i, long newValue)	将位置 i 的元素设置为给定值
boolean compareAndSet（int i，int expect，int update）	如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
boolean weakCompareAndSet(int i, int expect, long update)	如果当前值 == 预期值，则以原子方式将位置 i 的元素设置为给定的更新值
long getAndUpdate(int i, LongUnaryOperator updateFunction)	应用将给定函数利用以后值和给定值的原子更新以后值，返回旧值
long updateAndGet(int i, LongUnaryOperator updateFunction)	应用将给定函数利用以后值和给定值的原子更新以后值，返回新值

 2.1.3、示例：

package com.example.test.java.juc;import lombok.extern.slf4j.Slf4j;import java.util.concurrent.atomic.AtomicLongArray;
import java.util.function.LongBinaryOperator;
import java.util.function.LongUnaryOperator;@Slf4j(topic = "com.text.AtomicLongArray")
public class AtomicLongArrayTest {// 初始化 数组长度为 5private static AtomicLongArray arr = new AtomicLongArray(5);private static LongUnaryOperator longUnaryOperator = new LongUnaryOperator() {@Overridepublic long applyAsLong(long operand) {return operand + 10;}};private static LongBinaryOperator accumulatorFunction = new LongBinaryOperator() {@Overridepublic long applyAsLong(long left, long right) {return left + right;}};public static void main(String[] args) {for (int i = 0; i < arr.length(); i++) {log.debug("i-" + i + "=" + arr.get(i));}// 以原子形式给以后索引下标为（0）值加1，返回新值 （i++）： 0log.debug("索引 0 incrementAndGet=" + arr.getAndIncrement(0));// 以原子形式给以后索引下标为（0）值加1，，返回新值（++i）： 2log.debug("索引 0 incrementAndGet=" + arr.incrementAndGet(0));//以原子形式给以后索引下标为（0）值缩小 1，返回旧值 （i--）：2log.debug("索引 0 incrementAndGet=" + arr.getAndDecrement(0));//以原子形式给以后索引下标为（0）值缩小 1，返回旧值 （--i）：0log.debug("索引 0 incrementAndGet=" + arr.decrementAndGet(0));// 以原子形式将输出的数值与实例中的值（AtomicLongArray（0）里的value）相加，并返回后果 : 100log.debug("索引 0 addAndGet=" + arr.addAndGet(0, 100));// 获取 AtomicLongArray 的 value 100log.debug("索引 0 get=" + arr.get(0));log.debug("*********** JDK 1.8 ***********");//应用将给定函数利用给以后值和给定值的后果原子更新以后值，返回上一个值// 索引下标为 0 执行指定函数 后果为 100 + 10log.debug("索引 0 getAndUpdate=" + arr.updateAndGet(0, longUnaryOperator));// 索引下标为 1 执行指定函数 后果为 0 + 10log.debug("索引 1 getAndUpdate=" + arr.updateAndGet(1, longUnaryOperator));// 应用给定函数利用给指定下标和给定值的后果原子更新以后值，并返回后果 20log.debug("索引 1 accumulateAndGet=" + arr.accumulateAndGet(1, 10, accumulatorFunction));}
}

运行结果：

16:20:48.939 [main] DEBUG com.text.AtomicLongArray - i-0=0
16:20:48.945 [main] DEBUG com.text.AtomicLongArray - i-1=0
16:20:48.945 [main] DEBUG com.text.AtomicLongArray - i-2=0
16:20:48.945 [main] DEBUG com.text.AtomicLongArray - i-3=0
16:20:48.945 [main] DEBUG com.text.AtomicLongArray - i-4=0
16:20:48.945 [main] DEBUG com.text.AtomicLongArray - 索引 0 incrementAndGet=0
16:20:48.946 [main] DEBUG com.text.AtomicLongArray - 索引 0 incrementAndGet=2
16:20:48.946 [main] DEBUG com.text.AtomicLongArray - 索引 0 incrementAndGet=2
16:20:48.946 [main] DEBUG com.text.AtomicLongArray - 索引 0 incrementAndGet=0
16:20:48.946 [main] DEBUG com.text.AtomicLongArray - 索引 0 addAndGet=100
16:20:48.946 [main] DEBUG com.text.AtomicLongArray - 索引 0 get=100
16:20:48.946 [main] DEBUG com.text.AtomicLongArray - *********** JDK 1.8 ***********
16:20:48.946 [main] DEBUG com.text.AtomicLongArray - 索引 0 getAndUpdate=110
16:20:48.946 [main] DEBUG com.text.AtomicLongArray - 索引 1 getAndUpdate=10
16:20:48.947 [main] DEBUG com.text.AtomicLongArray - 索引 1 accumulateAndGet=20

2.2 AtomicReferenceArray介绍 

2.2.1、构造方法

方法名	说明
AtomicReferenceArray(E[] array)	创建与给定数组具有相同长度的新 AtomicReferenceArray，并从给定数组复制其所有元素。 这个构造方法传入一个数组对象时，该数组对象必须是引用类型，int[]不可以，但是Integer[]的可以
AtomicReferenceArray(int length)	创建给定长度的新 AtomicReferenceArray。 为数组的每一位设置什么值是没有要求的，类似于Map的形式

2.2.2、方法

方法	说明
boolean compareAndSet(int i, E expect, E update)	如果当前值 == 预期值，则以原子方式将位置 i 的元素设置为给定的更新值
E get(int i)	获取位置 i 的当前值
E getAndSet(int i, E newValue)	以原子方式将位置 i 的元素设置为给定值，并返回旧值
void lazySet(int i, E newValue)	最终将位置 i 的元素设置为给定值
int length()	返回该数组的长度
void set(int i, E newValue)	将位置 i 的元素设置为给定值
boolean weakCompareAndSet(int i, E expect, E update)	如果当前值 == 预期值，则以原子方式将位置 i 的元素设置为给定的更新值

 2.2.3、代码示例

package com.example.test.java.juc;import java.util.concurrent.atomic.AtomicReferenceArray;public class AtomicReferenceArrayTest {public static void main(String[] args) {Long[] l = new Long[4];String[] s = new String[4];int[] i = new int[4];Integer[] in = new Integer[4];AtomicReferenceArray atomicReferenceArray = new AtomicReferenceArray(l);System.out.println(atomicReferenceArray.length());System.out.println(atomicReferenceArray.get(2));AtomicReferenceArray atomic = new AtomicReferenceArray(4);atomic.set(0,12);atomic.set(2,"Leefs");atomic.set(3,i);System.out.println(atomic.toString());}
}

运行结果：

4
null
[12, null, Leefs, [I@15327b79]

3、原子性测试 

        创建10个线程，每个线程分别对数组操作（自增）10000次（采用了函数式编程）。

package com.example.test.java.juc;import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;public class AtomicArrayTest {/**参数1:提供数组、可以是线程不安全数组或线程安全数组参数2:获取数组长度的方法参数3:自增方法，回传 array, index参数4:打印数组的方法supplier 提供者 无中生有 ()->结果function 函数 一个参数一个结果 (参数)->结果,BiFunction (参数1,参数2)->结果consumer 消费者 一个参数没结果 (参数)->void,BiConsumer (参数1,参数2)->void*/private static <T> void demo(Supplier<T> arraySupplier,Function<T,Integer> lengthFun,BiConsumer<T,Integer> putConsumer,Consumer<T> printConsumer) {// 创建线程列表List<Thread> threadList = new ArrayList<>();// 得到数组返回的元素T array = arraySupplier.get();// 后面的Integer是返回结果int length = lengthFun.apply(array);// 根据数组长度来进行遍历，对值进行累加for (int i = 0; i < length; i++) {// 每个线程对数组作 10000 次操作threadList.add(new Thread(() -> {for (int j = 0; j < 10000; j++) {putConsumer.accept(array, j%length);}}));}threadList.forEach(t -> t.start()); // 启动所有线程threadList.forEach(t -> {try {t.join();} catch (InterruptedException e) {e.printStackTrace();}});// 等所有线程结束printConsumer.accept(array);}public static void main(String[] args) {// 不安全数据demo(()->new int[10],(array)->array.length,(array, index) -> array[index]++,array-> System.out.println(Arrays.toString(array)));// 安全数据demo(()->new AtomicIntegerArray(10),(arr)-> arr.length(),(arr,index) -> arr.getAndIncrement(index),(arr)-> System.out.println(arr));}
}

运行结果：

[9035, 9053, 9034, 9049, 9039, 9041, 9032, 9027, 9040, 9025]
[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]