Java 8的CompletableFuture在方法内使用不当，导致局部变量出现线程安全问题

package test;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.stream.IntStream;

/**
 * @version v1.0
 * @description:
 * @author: 47Gamer on 2020.9.16.016 上午 10:24
 */
public class T {


        private static final int SIZE = 1000000;


        public static void main(String[] args) {
            testCompletableFuture();
            testCompletableFuture2();
            testCompletableFuture3();
        }

        /**
         * 非线程安全，有时出现数组下标越界问题
         */
        public static void testCompletableFuture() {
            System.out.println("----start----" + LocalDateTime.now());
            //由于方法后面的add操作，这里的变量相当于全局变量，造成了线程安全问题出现
            List<Integer> list = new ArrayList<>();
            List<CompletableFuture<Void>> futureList = new ArrayList<>();
            IntStream.range(0, SIZE).forEach(i -> {
                //设置随机返回数字
                CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
                    Random random = new Random();
                    return random.nextInt(Integer.MAX_VALUE);
                }).thenAccept(list::add);       //添加到list，出现线程安全问题
                futureList.add(future);
            });
            //主线程阻塞等待所有异步线程完成任务
            futureList.forEach(CompletableFuture::join);
            System.out.println("testCompletableFuture - size :" + list.size());
            System.out.println("----end----" + LocalDateTime.now());
            System.out.println();
        }

        /**
         * 线程安全
         * 方法一：使用CopyOnWriteArrayList(合适读多写少的情况)替换ArrayList
         * 方法二：Collections.synchronizedList设置为线程安全类(这里测试比CopyOnWriteArrayList快)
         */
        public static void testCompletableFuture2() {
            System.out.println("----start----" + LocalDateTime.now());
            List<Integer> list = Collections.synchronizedList(new ArrayList<>());
            //List<Integer> list = new CopyOnWriteArrayList<>();
            List<CompletableFuture<Void>> futureList = new ArrayList<>();
            IntStream.range(0, SIZE).forEach(i -> {
                //设置随机返回数字
                CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
                    Random random = new Random();
                    return random.nextInt(Integer.MAX_VALUE);
                }).thenAccept(list::add);       //添加到list,不会出现线程安全问题
                futureList.add(future);
            });
            //主线程阻塞等待所有异步线程完成任务
            futureList.forEach(CompletableFuture::join);
            System.out.println("testCompletableFuture2 - size : " + list.size());
            System.out.println("----end----" + LocalDateTime.now());
            System.out.println();
        }


        /**
         * 线程安全
         * 使用join方法再添加到ArrayList
         */
        public static void testCompletableFuture3() {
            System.out.println("----start----" + LocalDateTime.now());
            List<Integer> list = new ArrayList<>();
            List<CompletableFuture<Integer>> futureList = new ArrayList<>();
            IntStream.range(0, SIZE).forEach(i -> {
                //设置随机返回数字
                CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
                    Random random = new Random();
                    return random.nextInt(Integer.MAX_VALUE);
                });
                futureList.add(future);
            });
            //主线程阻塞等待所有异步线程完成任务，并在join返回结果再添加到ArrayList，就不会出现线程安全问题
            futureList.forEach(future-> list.add(future.join()));
            System.out.println("testCompletableFuture3 - size : " + list.size());
            System.out.println("----end----" + LocalDateTime.now());
        }

}