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

最近在项目使用Java8 的CompletableFuture执行一些异步多线程任务，一时疏忽，导致ArrayList出现线程安全问题

就算在方法内使用局部变量，但使用异步多线程执行任务，还是会出现线程安全问题

以下是错误、正确使用的示例方法

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;

/**
 * 测试CompletableFutrue
 * Created by earl on 2018/4/26.
 */
public class Test {


    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());
    }



}