多线程使用场景

场景1：当某个接口响应速度很慢的时候，可以使用多线程提升响应速度。前提是这个接口获取信息的逻辑互相独立，比如首页接口，需要获取列表A，列表B，列表C等，而列表ABC三者之间互相独立（也就是不需要获取到A，就能获取到B），互相之间没有关系。这种情况就可以使用多线程去优化，总耗时为获取3个列表当中耗时最长的那个。

实现方式1，使用Callable+线程池

public class Test {

    ExecutorService executorService = Executors.newFixedThreadPool(3);
    
    public List<Object> get(List<String> list, final int threadNum) throws Exception {
        // 保存各个线程执行后的结果集
        List<Future<List<String>>> futures = new ArrayList<>(3);
        Callable<List<String>> task1 = new Callable<List<String>>() {
            @Override
            public List<String> call() throws Exception {
                //获取列表A
                List<String> list1 = new ArrayList<>();
                return list1;
            }
        };
        Callable<List<String>> task2 = new Callable<List<String>>() {
            @Override
            public List<String> call() throws Exception {
                //获取列表B
                List<String> list2 = new ArrayList<>();
                return list2;
            }
        };

        Callable<List<String>> task3 = new Callable<List<String>>() {
            @Override
            public List<String> call() throws Exception {
                //获取列表C
                List<String> list2 = new ArrayList<>();
                return list2;
            }
        };
        //添加线程到队列
        futures.add(executorService.submit(task1));
        futures.add(executorService.submit(task2));
        futures.add(executorService.submit(task3));

        //主线程会阻塞在这里，直到3个子线程执行完成
        //结果集汇总
        List<Object> res = new ArrayList<>();
        for (int i = 0; i < futures.size(); i++) {
            res.add(futures.get(i).get());
        }
        executorService.shutdown();
        return res;
    }
}

实现方式2：使用CompletableFuture实现
（参考https://juejin.cn/post/7140244126679138312#heading-15）

public class CompletableFutureDemo {

    public static void main(String[] args) throws Exception, InterruptedException {

        new CompletableFutureDemo().getRes();
    }

    public List<Object> getRes() throws ExecutionException, Exception {
        List<Future<List<String>>> futures = new ArrayList<>(3);
        CompletableFuture<List<String>> task1 = CompletableFuture.supplyAsync(() -> {
            //获取列表A
            List<String> list1 = new ArrayList<>();
            list1.add("1");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return list1;
        }).exceptionally(throwable -> {
            return new ArrayList<>();
        });

        CompletableFuture<List<String>> task2 = CompletableFuture.supplyAsync(() -> {
            //获取列表B
            List<String> list1 = new ArrayList<>();
            list1.add("2");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return list1;
        }).exceptionally(throwable -> {
            return new ArrayList<>();
        });

        CompletableFuture<List<String>> task3 = CompletableFuture.supplyAsync(() -> {
            //获取列表C
            List<String> list1 = new ArrayList<>();
            list1.add("3");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return list1;
        }).exceptionally(throwable -> {
            return new ArrayList<>();
        });
        futures.add(task1);
        futures.add(task2);
        futures.add(task3);
        List<Object> res = new ArrayList<>();
        for (int i = 0; i < futures.size(); i++) {
            res.add(futures.get(i).get());
        }
        return res;
    }
}

这里为什么没有使用线程池，其实CompletableFuture类就是使用线程池实现的，使用的是ForkJoinPool实现，这个是基于工作窃取实现的线程池，具体可以自行了解一下ForkJoinPool和ThreadPoolExecutor的区别。

场景2：多线程分批次处理集合数据，不处理重复的数据。比如有一张学生表，数据量很大，你需要根据表当中的姓名和身份证号这两个字段去调用外部接口(外部接口一次只能校验一条数据)，校验之后还需要更新这张表。这个时候可以使用多线程分批次处理，大大提高效率。

示例demo：

public class TestApp {

    //配置需要同时开启多少个线程进行处理
    private final int threadNum = 10;

    /**
     * @param list 要处理的集合数据，如果查询较慢，可以多线程分批次查询然后汇总在一块
     */
    public void handleData(List<User> list)  {
        int size = list.size();
        if (size == 0 || list == null) {
            return;
        }
        ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
        List<Future<List<User>>> futures = new ArrayList<Future<List<User>>>(size);
        for (int i = 0; i < threadNum; i++) {
            //将数据分成threadNum份，线程同时执行
            int from = size / threadNum * i;
            int to = size / threadNum * (i + 1);
            if (i == threadNum - 1) {
                to = size;
            }
            List<User> subList = list.subList(from, to);
            Callable<List<User>> task = new Callable<List<User>>() {
                @Override
                public List<User> call()  {
                    List<User> list1 = new ArrayList<>();
                    //对每个线程(线程中的每份数据)的逻辑操作
                    for (User user : subList) {
                        //调用外部接口
                        Boolean res = checkNameAndIdCard(user.getName, user.getIdCard);
                        user.setRes(res);
                        list1.add(user);
                    }
                    return list1;
                }
            };
            //添加线程到队列
            futures.add(executorService.submit(task));
        }
        //多线程处理后的集合汇总到all
        List<User> all = new ArrayList<>();
        for (int i = 0; i < futures.size(); i++) {
            try {
                List<User> list1 = futures.get(i).get();
                all.addAll(list1);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        //批量更新数据库

        executorService.shutdown();
    }


    /**
     * 模拟外部接口
     */
    public Boolean checkNameAndIdCard(String name, String idCard) {
        return true;
    }

}


@Data
class User {
    private Integer id;
    private String name;
    private String idCard;
    private String res;
}

整体流程：
先把要处理的集合从数据库全部捞出来
根据要开的线程数量对集合进行均分
开多线程对每个集合进行处理，处理后返回结果

Future.get()会造成主线程阻塞，也就是当所有future都得到结果后主线程才能继续执行下去

场景3：做异步。比如页面上需要导出excel文件，由于业务要求，需要导出全部数据，导出全部数据大概需要10分钟左右，那如果使用同步的方式，用户需要在这个导出页面等待10分钟，不能做其它操作，这样肯定是不行的。那么可以采用异步，用户点击导出，导出接口主线程往数据库当中插入一条导出记录，开个子线程获取数据，写入Excel文件，完成之后更新导出记录，当中，然后主线程直接给用户返回。这样用户点击导出会生成一个导出记录信息，不用在这里等待，等导出完成，之后可以在导出记录当中进行下载。代码就不贴了。

场景4：监听线程，如果某个线程执行时间过长(可能死循环了)，超过了自定义的时间，就把该线程干掉，释放cpu资源

情况1：开一个线程去执行这个任务
示例demo：

public class MainSingle {

    public static final ExecutorService pool = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws Exception {

        Runnable runnable = new Runnable() {
            @Override
            public void run()  {
                System.out.println(Thread.currentThread().getName() + "进来了" + this.hashCode());
                try {
                    Thread.sleep(7000);
                } catch (InterruptedException e) {}
            }
        };
        
        FutureTask futureTask = new FutureTask<>(runnable,null);
        pool.submit(futureTask);
        long start = System.currentTimeMillis();
        // 判断是否完成,如果没完成就是一直循环判断
        while (!futureTask.isDone()) {
            long now = System.currentTimeMillis();
            if ((now - start) >= 6000) {//超时时间3000毫秒
                futureTask.cancel(true);
                System.out.println("线程超时了，终止");
            }
        }
        pool.shutdown();
    }

}

情况2：开多个线程，哪个线程死循环，就关闭哪一个线程，不影响其它线程

public class MainMore implements Runnable {

    //线程池
    public static final ExecutorService pool = Executors.newFixedThreadPool(12);

    @Override
    public void run() {


        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "进来了" + this.hashCode());
                try {
                    Thread.sleep(7000);
                } catch (InterruptedException e) {
                }
            }
        };
        FutureTask task = new FutureTask(runnable, null);
        new Thread(task).start();

        long start = System.currentTimeMillis();
        while (!task.isDone()) {// 判断是否完成
            long now = System.currentTimeMillis();
            if ((now - start) >= 3000) {//超时时间3000毫秒
                task.cancel(true);
                System.out.println(Thread.currentThread().getName() + "线程超时了，终止");
            }
        }
    }

    public static void main(String[] args) throws Exception {
        for (int i = 0; i < 3; i++) {
            pool.submit(new MainMore());
        }
        pool.shutdown();
    }
}

以上是我在工作当中真实遇到的一个多线程使用场景，在这里做一个小总结。