并发编程学习（十一）：原子数组、

偏执的太偏执、 2023-09-27 20:51 27阅读 0赞

## 1、数组类型的原子类 ##

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

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

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

<table> 
 <thead> 
  <tr> 
   <th>类名</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong><code>AtomicIntegerArray</code></strong></td> 
   <td>提供对int[]数组元素的原子性更新操作</td> 
  </tr> 
  <tr> 
   <td><strong><code>AtomicLongArray</code></strong></td> 
   <td>提供对long[]数组元素的原子性更新操作</td> 
  </tr> 
  <tr> 
   <td><strong><code>AtomicReferenceArray</code></strong></td> 
   <td>提供对<code>引用类型[]</code>数组元素的原子性更新操作</td> 
  </tr> 
  <tr> 
   <td><strong><code>AtomicBooleanArray</code></strong></td> 
   <td>原子更新布尔类型数组的元素</td> 
  </tr> 
 </tbody> 
</table>

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

## 2、常用方法 ##

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

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

### 2.1、AtomicLongArray介绍 ###

#### 2.1.1、构造方法 ####

<table> 
 <thead> 
  <tr> 
   <th style="width:246px;">方法名</th> 
   <th style="width:442px;">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:246px;">AtomicLongArray(int length)</td> 
   <td style="width:442px;">创建给定长度的新&nbsp;<code>AtomicLongArray</code></td> 
  </tr> 
  <tr> 
   <td style="width:246px;">AtomicLongArray(long[] array)</td> 
   <td style="width:442px;">创建与给定数组具有相同长度的新&nbsp;<code>AtomicLongArray</code>，并从给定数组复制其所有元素</td> 
  </tr> 
 </tbody> 
</table>

#### 2.1.2、方法 ####

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

#### 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 {
    
        // 初始化 数组长度为 5
        private static AtomicLongArray arr = new AtomicLongArray(5);
    
        private static LongUnaryOperator longUnaryOperator = new LongUnaryOperator() {
            @Override
            public long applyAsLong(long operand) {
                return operand + 10;
            }
    
        };
    
        private static LongBinaryOperator accumulatorFunction = new LongBinaryOperator() {
    
            @Override
            public 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++）： 0
            log.debug("索引 0 incrementAndGet=" + arr.getAndIncrement(0));
    
            // 以原子形式给以后索引下标为（0）值加1，，返回新值（++i）： 2
            log.debug("索引 0 incrementAndGet=" + arr.incrementAndGet(0));
    
            //以原子形式给以后索引下标为（0）值缩小 1，返回旧值 （i--）：2
            log.debug("索引 0 incrementAndGet=" + arr.getAndDecrement(0));
    
            //以原子形式给以后索引下标为（0）值缩小 1，返回旧值 （--i）：0
            log.debug("索引 0 incrementAndGet=" + arr.decrementAndGet(0));
    
            // 以原子形式将输出的数值与实例中的值（AtomicLongArray（0）里的value）相加，并返回后果 : 100
            log.debug("索引 0 addAndGet=" + arr.addAndGet(0, 100));
    
            // 获取 AtomicLongArray 的 value 100
            log.debug("索引 0 get=" + arr.get(0));
    
            log.debug("*********** JDK 1.8 ***********");
    
            //应用将给定函数利用给以后值和给定值的后果原子更新以后值，返回上一个值
            // 索引下标为 0 执行指定函数 后果为 100 + 10
            log.debug("索引 0 getAndUpdate=" + arr.updateAndGet(0, longUnaryOperator));
    
            // 索引下标为 1 执行指定函数 后果为 0 + 10
            log.debug("索引 1 getAndUpdate=" + arr.updateAndGet(1, longUnaryOperator));
    
            // 应用给定函数利用给指定下标和给定值的后果原子更新以后值，并返回后果 20
            log.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、构造方法 ####

<table> 
 <thead> 
  <tr> 
   <th style="width:263px;">方法名</th> 
   <th style="width:425px;">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:263px;"><strong>AtomicReferenceArray</strong>(E[] array)</td> 
   <td style="width:425px;"> <p>创建与给定数组具有相同长度的新&nbsp;<code>AtomicReferenceArray</code>，并从给定数组复制其所有元素。</p> <p>这个构造方法传入一个数组对象时，该<strong><span style="background-color:#ffd900;">数组对象必须是引用类型</span></strong>，int[]不可以，但是Integer[]的可以</p> </td> 
  </tr> 
  <tr> 
   <td style="width:263px;"><strong>AtomicReferenceArray</strong>(int length)</td> 
   <td style="width:425px;"> <p>创建给定长度的新 AtomicReferenceArray。</p> <p>为数组的每一位设置什么值是没有要求的，类似于Map的形式</p> </td> 
  </tr> 
 </tbody> 
</table>

#### 2.2.2、方法 ####

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

#### 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\]