异步中使用回调函数影响主线程执行

问题产生

还是上次的大批量数据导入的问题，里面有个逻辑，需要一行一行的校验数据的正确性，一旦又一行数据不满足要求，整个线程就要停止，用数组接收future,然后再最后遍历所有future这种方法在这里显然并非优解。

问题解决

办法千千万，这里介绍一下我的解决方法，那就是使用回调函数，在回调函数里把当前的线程池shutdown掉，这样后续submit就会抛出异常。

以下是demo代码：

public class FutureDemo {

    public static void main(String[] args) throws InterruptedException {
        // 存放异步返回结果的List
        List<FutureTask<Integer>> list = new ArrayList<>();
        // 线程池
        ExecutorService executor = new ThreadPoolExecutor(5,10,10,TimeUnit.SECONDS,new ArrayBlockingQueue<>(5));
        
        final List<String> results = new ArrayList<String>();


        try{
            // 弄5个线程，其中第二个线程的时候，让线程调用回调函数，停止主引用
            Task task = new Task(10, new Callback() {
                @Override
                public void callbackmsq(String callback) throws Exception {
                    if(callback != null ){
                        executor.shutdown();
                    }
                }
            });
            FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
            executor.submit(futureTask);
            list.add(futureTask);
            
            Thread.sleep(1000);
            Task task1 = new Task(11, new Callback() {
                @Override
                public void callbackmsq(String callback) throws Exception {
                    if(callback != null ){
                        results.add("程序停了") ;
                        executor.shutdown();
                    }
                }
            });
            FutureTask<Integer> futureTask1 = new FutureTask<Integer>(task1);
            executor.submit(futureTask1);
            list.add(futureTask1);

            Thread.sleep(1000);
            Task task2 = new Task(12, new Callback() {
                @Override
                public void callbackmsq(String callback) throws Exception{
                    if(callback != null ){
                        results.add("程序停了") ;
                        executor.shutdown();
                    }
                }
            });
            FutureTask<Integer> futureTask2 = new FutureTask<Integer>(task2);
            executor.submit(futureTask2);
            list.add(futureTask2);

            Thread.sleep(1000);
            Task task3 = new Task(13, new Callback() {
                @Override
                public void callbackmsq(String callback) throws Exception{
                    if(callback != null ){
                        results.add("程序停了") ;
                        executor.shutdown();
                    }
                }
            });
            FutureTask<Integer> futureTask3 = new FutureTask<Integer>(task3);
            executor.submit(futureTask3);
            list.add(futureTask3);

            Thread.sleep(1000);
            Task task4 = new Task(14, new Callback() {
                @Override
                public void callbackmsq(String callback) throws Exception{
                    if(callback != null ){
                        results.add("程序停了") ;
                        executor.shutdown();
                    }
                }
            });
            FutureTask<Integer> futureTask4 = new FutureTask<Integer>(task4);
            executor.submit(futureTask4);
            list.add(futureTask4);

            executor.shutdown();
        }catch (Exception e){
            e.printStackTrace();
            System.out.println("异步执行结果" + results);
        }


        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;

    private Callback callback;

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

    @Override
    public Integer call() throws Exception {
        System.out.println( "子线程在进行计算，当前num值：" + num );
        if(num == 10){
            Thread.sleep( 1000 );
        }
        if(num==11) {
            Thread.sleep( 2000 );
            System.out.println("11了，赶紧停主应用");
            callback.callbackmsq("11了，赶紧停主应用");
        }
        // 从0加到num-1
        int sum = 0 ;
        for ( int i= 0 ;i< num ;i++)
            sum += i;
        return sum;
    }
}

abstract class Callback{
    public abstract void callbackmsq(String callback) throws Exception;
}

以下是Demo执行结果：