原子数组

在我们对数组元素里面的内容进行更改时，若要保证线程安全，则需要可以通过AtomicIntegerArray 这个类。

代码示例：

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),
                (array) -> array.length(),
                (array, index) -> array.incrementAndGet(index),
                array -> System.out.print(array));
    }

    public static <T> void demo(Supplier<T> supplier,
                                Function<T, Integer> function,
                                BiConsumer<T, Integer> biConsumer,
                                Consumer<T> consumer) {
        List<Thread> threads = new ArrayList<>();
        // 获得数组
        T array = supplier.get();
        // 根据数据获得数组长度
        int length = function.apply(array);
        // 创建10个线程
        for (int i=0; i<length; i++) {
            threads.add(new Thread(() -> {
                for (int j=0; j<10000; j++) {
                    // 每个线程在数组每个元素上加了1000次
                    biConsumer.accept(array, j%length);
                }
            }));
        }

        threads.forEach(Thread::start);
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        consumer.accept(array);
    }

说明：上诉代码做的事就是让10个线程对一个大小为10的数组中的每个元素加1000，那么如果算下来的话，10个线程应该刚好加到10000，第一个运行的结果是用普通数组来做的，可以看到每个元素都不为10000，第二个运行的结果是用AtomicIntegerArray来做的，运行的结果刚好和预期的一样，都是10000，所以得出结论，AtomicIntegerArray类是使得数组元素线程安全的类。

运行结果：