CompletableFuture的多线程和异步监听实现

最新推荐文章于 2025-10-27 20:52:02 发布

原创最新推荐文章于 2025-10-27 20:52:02 发布 · 3k 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#java #CompletableFuture #多线程 #异步监听 #异步回调

JAVA 专栏收录该内容

77 篇文章

订阅专栏

本文介绍使用CompletableFuture实现多线程并发时的异步监听方法。通过具体示例展示了如何利用CompletableFuture来同时执行多个任务，并确保所有任务完成后进行下一步操作。

大家好,我是烤鸭：
今天给大家说的是多线程并发的异步监听的情况。
这里不得不说一下CompletableFuture这个类，普通我们执行多线程的时候只需要另外启动一条线程。
说一下线程的3种方式：

extends Thread，implements Runnable，implements Callable。

同步的实现方式有很多。这里贴一下我的。

这个handler是可以注入其他的比如service或者dao，完成业务逻辑，我这里是注入的redis。

package com.mys.my.wechat.handler;

import com.mys.my.wechat.config.redis.RedisClient;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Executor;

@Service("musicHandler")
public class MusicHandler {
    public static Log logger = LogFactory.getLog(MusicHandler.class);
    public String redisString;
    public String openId;

    @Autowired
    private RedisClient redisClient;
    @Autowired
    private Executor taskAsyncPool;

    public void doAllHandler() {
        try {
            taskAsyncPool.execute(new Runnable() {
                @Override
                public void run() {
                    logger.info("xiami 任务启动");
                    Date time = new Date();
//                  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//                  String re_StrTime = sdf.format(time);
                    //过期时间1小时
                    redisClient.set("xiamiMusic:"+openId,redisString,60*60);
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

调用：

                   //存redis
                    musicHandler.redisString = toJson;
                    musicHandler.openId = openId;
                    musicHandler.doAllMusicHandler();

以上就是同步调用，但是这样只是执行，你无法监听结果。

我现在说一下场景：

烧水的同时，洗衣机洗衣服，电脑下载，手机充电，我们生活中

也会有同时干几件事的情况，而需求是这几件事都干完了我才能出门，多线程确实能执行，但是怎么监听结果呢。

以上也许可以说时间是可以预测的。

但是具体的业务场景，如果需要你去调用4个接口，而他们之间的没有任何影响，但是又必须

4个接口都执行完才能返回数据。这样如果实现多线程的异步监听呢？

最常用的就是爬虫，我想同时抓取几个网站或者几个网页的数据，如果是单线程，效率很低。

多线程又必须保证每条线程完成抓取并返回数据。以下是一个小例子。

用CompletableFuture，代码如下：

package com.mys.my.wechat.service.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.CompletableFuture;

final Integer res = 0;
        final ArrayList<Integer> integers = new ArrayList<>();
            CompletableFuture<Integer> completableFuture1 = CompletableFuture.supplyAsync(() -> {
                //模拟执行耗时任务
                System.out.println("task 1 doing...");
                try {
                   Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //返回结果
                return 1;
            });
            //注册完成事件
            completableFuture1.thenAccept(result -> {
                integers.add(1);
            });
        CompletableFuture<Integer> completableFuture2 = CompletableFuture.supplyAsync(() -> {
            //模拟执行耗时任务
            System.out.println("task 2 doing...");
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            //返回结果
            return 1;
        });
        //注册完成事件
        completableFuture2.thenAccept(result -> {
            integers.add(1);
        });
        CompletableFuture<Integer> completableFuture3 = CompletableFuture.supplyAsync(() -> {
            //模拟执行耗时任务
            System.out.println("task 3 doing...");
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            //返回结果
            return 1;
        });
        //注册完成事件
        completableFuture3.thenAccept(result -> {
            integers.add(1);
        });
        while(true){
            try {
                Thread.sleep(1000);
                if(integers.size()== 3){
                    System.out.println("done");
                    break;
                }
                System.out.println("s:"+integers.size());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

这里我们可以看到，主线程一直在监听，其他新开启的3个线程，如果他们执行完毕，就可以返回数据，
如果他们有没执行完的，主线程就一直等。这样就分工明确了，主线程的任务就是监视其他是否完毕，

而同时开启3条线程执行速度也会很快。

这只是一个demo和想法实现，欢迎交流。