JDKCompletableFuture 使用case

最新推荐文章于 2023-11-17 17:36:32 发布

原创最新推荐文章于 2023-11-17 17:36:32 发布 · 210 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #stream #jdk

java后端学习专栏收录该内容

10 篇文章

订阅专栏

该博客探讨了如何使用Java的CompletableFuture进行异步任务处理，并通过配置线程池来优化性能。示例代码展示了如何创建并行任务，模拟接口调用延迟，并通过allOf方法等待所有任务完成。同时，还实现了一个评估函数，根据编辑距离计算结果的相似度，并对结果进行排序。

public class JDKCompletableFutureTest {
    private static ExecutorService executorService = new ThreadPoolExecutor(
            Config.get().getInt("engine.search.CompletableFuture.pool.core.size",
                    Runtime.getRuntime().availableProcessors() * 2),
            Config.get().getInt("engine.search.CompletableFuture.pool.max.size",
                    Runtime.getRuntime().availableProcessors() * 10),
            60L,
            TimeUnit.SECONDS,
            new LinkedBlockingQueue<Runnable>(Config.get().getInt(
                    "engine.executor.CompletableFuture.queue.size", 5000))
    );

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


        long time = System.currentTimeMillis();
        CompletableFuture<MarklandBean> f1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(4000); // 模拟接口调用耗时1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            MarklandBean marklandBean = new MarklandBean();
            marklandBean.setName("人民广场大动静店");
            return marklandBean;
        }, executorService);
        CompletableFuture<MarklandBean> f2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2500); // 模拟接口调用耗时1.5秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            MarklandBean marklandBean = new MarklandBean();
            marklandBean.setName("人民广场动静分店");
            return marklandBean;
        });
        CompletableFuture<MarklandBean> f3 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(2900); // 模拟接口调用耗时0.6秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            MarklandBean marklandBean = new MarklandBean();
            marklandBean.setName("人广淞虹路分店");
            return marklandBean;
        });

        List<CompletableFuture<MarklandBean>> list = new ArrayList<>();
        list.add(f1);
        list.add(f2);
        list.add(f3);
        Thread.sleep(1200);
        CompletableFuture<Void> f4 = CompletableFuture.allOf(list.toArray(new CompletableFuture[]{}));

        String inputWord = "人民广场淞虹路分店";
        System.out.println("耗时1:" + (System.currentTimeMillis() - time));
        MarklandBean result = getMarklandBean(list, inputWord);
        System.out.println("耗时2:" + (System.currentTimeMillis() - time));
    }

    private static MarklandBean getMarklandBean(List<CompletableFuture<MarklandBean>> list, String inputWord) {
        list.forEach(f -> {
            try {
                System.out.println("异步结果:" + f.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        MarklandBean result = null;
        try {
            List<MarklandBean> results = list.stream().filter(it -> it != null).map(it -> {
                MarklandBean i = null;
                try {
                    i = it.get(1000, TimeUnit.MILLISECONDS);
                    i.setLat(evaluate(i.getName(), inputWord));
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return i;
            }).sorted(Comparator.comparing(MarklandBean::getLat).reversed()).collect(Collectors.toList());

            result = results.stream().findFirst().get();

            results.forEach(f -> {
                try {
                    System.out.println("排序后的结果是:" + f);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
            System.out.println("最好的地标:" + result.getName());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    public static double evaluate(String a, String b) {
        if (a == null && b == null) {
            return 1f;
        }
        if (a == null || b == null) {
            return 0F;
        }
        int editDistance = StringUtils.getLevenshteinDistance(a, b);
        return 1 - ((double) editDistance / Math.max(a.length(), b.length()));
    }
}