异步Future在生产中的运用

问题产生

最近生产项目中出现一个问题，业务人员导入大量数据的时候，导入的时间过长，引发了业务的投诉，并提出了优化需求。
问题原因为导入数据起初就不是为大数据导入而开发的，里面涉及到了每一行数据的规则校验，所以拖累了整体的导入效率。

问题解决

这让我想起了早些年开发的大批量导入的一个项目需求，其用到的主要技术即为异步Future，开启多个线程，然后把线程返回的Future暂时存放在一个数组里面，这里由于没有调用get方法，所以主线程并不会阻塞，放完了所有的Future之后，在最后用一个遍历，get出结果。

Executors创建线程，由于没有对线程的等待队列，线程个数加以限制，一不小心就会出现OOM，所以这里用new ThreadPoolExecutor比较保险，以下是Demo代码：

public class FutureDemo {

    public static void main(String[] args) {
        // 存放异步返回结果的List
        List<FutureTask<Integer>> list = new ArrayList<>();
        // 线程池
        ExecutorService executor = new ThreadPoolExecutor(5,10,10,TimeUnit.SECONDS,new ArrayBlockingQueue<>(5));
        
        // 弄四个线程，其中第一个线程弄成等待三秒
        
        Task task = new Task(10);
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        executor.submit(futureTask);
        list.add(futureTask);
        
        Task task1 = new Task(11);
        FutureTask<Integer> futureTask1 = new FutureTask<Integer>(task1);
        executor.submit(futureTask1);
        list.add(futureTask1);
        
        Task task2 = new Task(12);
        FutureTask<Integer> futureTask2 = new FutureTask<Integer>(task2);
        executor.submit(futureTask2);
        list.add(futureTask2);
        
        Task task3 = new Task(13);
        FutureTask<Integer> futureTask3 = new FutureTask<Integer>(task3);
        executor.submit(futureTask3);
        list.add(futureTask3);
        
        Task task4 = new Task(14);
        FutureTask<Integer> futureTask4 = new FutureTask<Integer>(task4);
        executor.submit(futureTask4);
        list.add(futureTask4);

        executor.shutdown();

        try {
            for(FutureTask<Integer> item:list){
                System.out.println( "task运行结果" +item.get());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println( "所有任务执行完毕" );
    }

}
class Task implements Callable<Integer>{

    private int num = 0;

    public Task (int num) {
        this.num = num;
    }

    @Override
    public Integer call() throws Exception {
        System.out.println( "子线程在进行计算，当前num值：" + num );
        if(num == 10){
            Thread.sleep( 3000 );
        }
        // 从0加到num-1
        int sum = 0 ;
        for ( int i= 0 ;i< num ;i++)
            sum += i;
        return sum;
    }
}

Demo运行结果