如何让Callable从API预定义的void回调中返回String值？

核心思路 #

利用同步工具类让call()方法阻塞，直到endOfJobCallback()触发后再返回结果。最直接的实现方式是使用CountDownLatch，它可以让一个线程等待其他线程完成指定操作。

具体实现代码 #

修改你的MyCallable类，添加同步控制并处理线程安全问题：

import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class MyCallable implements someAPIWrapper, Callable<String> {
    
    // 用**volatile**保证多线程下的变量可见性，避免线程缓存导致的旧值读取
    private volatile String result;
    // 初始化计数为1的CountDownLatch，仅需回调触发一次即可解除阻塞
    private final CountDownLatch latch = new CountDownLatch(1);

    @Override
    public void endOfJobCallback() {
        // 此处完成result的最终赋值（比如拼接所有接收的消息）
        // result = "处理完成的最终字符串";
        
        // 通知等待的call()线程：任务已完成
        latch.countDown();
    }

    @Override
    public String call() throws Exception {
        // 1. 执行API调用，启动数据接收与监听逻辑
        // make API call to request a bunch of data
        // 启动消息循环，将收到的内容追加到result变量
        
        // 2. 阻塞当前线程，直到回调触发countDown()
        // 建议添加超时时间，避免因API异常导致永久阻塞
        if (!latch.await(10, TimeUnit.SECONDS)) {
            throw new RuntimeException("API任务超时未完成");
        }
        
        // 3. 返回最终处理结果
        return result;
    }
}

class Main {
    public static void main(String[] args) throws Exception {
        MyCallable callable = new MyCallable();
        ExecutorService executor = Executors.newFixedThreadPool(2);
        Future<String> future = executor.submit(callable);
        String result = future.get(); // 此处会阻塞直到回调完成或超时
        executor.shutdown();
    }
}

关键细节说明 #

• volatile修饰result：确保回调线程对result的修改能被call()所在线程立即感知，避免多线程环境下的内存可见性问题。
• CountDownLatch的作用：call()方法调用await()后进入阻塞状态，直到endOfJobCallback()中调用countDown()将计数减为0，此时阻塞解除，call()继续执行并返回结果。
• 超时保护：给latch.await()添加超时参数，防止因API故障、回调未触发等情况导致线程永久阻塞。
• 异常处理：如果API调用过程中出现错误，可在监听逻辑或回调中捕获异常，设置result为错误信息，或直接抛出异常让future.get()感知到错误。

替代方案：使用CompletableFuture（无需实现Callable） #

如果不需要严格实现Callable接口，用CompletableFuture可以更简洁地实现异步转同步：

import java.util.concurrent.CompletableFuture;

public class MyAPIHandler implements someAPIWrapper {
    private final CompletableFuture<String> future = new CompletableFuture<>();

    @Override
    public void endOfJobCallback() {
        String result = "处理完成的最终字符串";
        future.complete(result);
    }

    public CompletableFuture<String> startJob() {
        // 执行API调用与消息监听逻辑
        return future;
    }
}

// 调用示例
class Main {
    public static void main(String[] args) throws Exception {
        MyAPIHandler handler = new MyAPIHandler();
        CompletableFuture<String> future = handler.startJob();
        String result = future.get();
    }
}

内容的提问来源于stack exchange，提问作者limestreetlab