前言:工作中遇到个问题,调用外部api启用异步线程时需进行超时控制,调研后得出以下结论。
Java 8 的 CompletableFuture 并没有 timeout 机制,虽然可以在 get 的时候指定 timeout,是一个同步堵塞的操作。怎样让 timeout 也是异步的呢?
Java 8 内有内建的机制支持,一般的实现方案是启动一个 ScheduledThreadpoolExecutor 线程在 timeout 时间后直接调用 CompletableFuture.completeExceptionally(newTimeoutException()), 然后用acceptEither() 或者 applyToEither 看是先计算完成还是先超时:
在 java 9 就方便多了,直接引入了 orTimeout 和 completeOnTimeOut 两个方法支持 异步 timeout 机制:
1、public CompletableFuture orTimeout(long timeout, TimeUnit unit) : completes the CompletableFuture with a TimeoutException after the specified timeout has elapsed.
2、public CompletableFuture completeOnTimeout(T value, long timeout, TimeUnit unit) : provides a default value in the case that the CompletableFuture pipeline times out.
内部实现上跟我们上面的实现方案是一模一样的,只是现在不需要自己实现了。
实际上hystrix等熔断的框架,其实现线程Timeout之后就关闭线程,也是基于同样的道理,所以我们可以看到hystrix中会有一个Timer Thread
话不多说 直接来代码
CompletableFuture超时工具 (JDK8)
public class CompletableFutureTimeoutUtil {
/**
* Singleton delay scheduler, used only for starting and * cancelling tasks.
*/
static final class Delayer {
static ScheduledFuture<?> delay(Runnable command, long delay,
TimeUnit unit) {
return delayer.schedule(command, delay, unit);
}
static final class DemoThreadFactory implements ThreadFactory {
@Override
public Thread newThread(Runnable r) {
Thread t = new Thread(r);
t.setDaemon(true);
t.setName("CompletableFutureDelayScheduler");
return t;
}
}
static final ScheduledThreadPoolExecutor delayer;
// 注意,这里使用一个线程就可以搞定 因为这个线程并不真的执行请求 而是仅仅抛出一个异常
static {
(delayer = new ScheduledThreadPoolExecutor(
1, new CompletableFutureTimeoutUtil.Delayer.DemoThreadFactory())).
setRemoveOnCancelPolicy(true);
}
}
public static <T> CompletableFuture<T> timeoutAfter(long timeout, TimeUnit unit) {
CompletableFuture<T> result = new CompletableFuture<T>();
// timeout 时间后 抛出TimeoutException 类似于sentinel / watcher
CompletableFutureTimeoutUtil.Delayer.delayer.schedule(() -> result.completeExceptionally(new TimeoutException()), timeout, unit);
return result;
}
/**
* 哪个先完成 就apply哪一个结果 这是一个关键的API,exceptionally出现异常后返回默认值
*
* @param t
* @param future
* @param timeout
* @param unit
* @param <T>
* @return
*/
public static <T> CompletableFuture<T> completeOnTimeout(T t, CompletableFuture<T> future, long timeout, TimeUnit unit) {
final CompletableFuture<T> timeoutFuture = timeoutAfter(timeout, unit);
return future.applyToEither(timeoutFuture, Function.identity()).exceptionally((throwable) -> t);
}
}
测试Demo
public class Demo{
public static void main(String[] args) throws ExecutionException, InterruptedException {
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return 10;
});
CompletableFuture<Integer> within = CompletableFutureTimeoutUtil.completeOnTimeout(1, future, 3, TimeUnit.SECONDS);
System.out.println(within.get());
CompletableFuture<String> futureStr = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
return "正常执行";
});
CompletableFuture<String> withinStr = CompletableFutureTimeoutUtil.completeOnTimeout("超时执行", futureStr, 1, TimeUnit.SECONDS);
System.out.println(withinStr.get());
}
}
方式二:
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class CompletableFutureTimeout {
private static final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
public static <T> CompletableFuture<T> completeOnTimeout(
T value, long timeout, TimeUnit unit) {
final CompletableFuture<T> promise = new CompletableFuture<>();
scheduler.schedule(() -> promise.complete(value), timeout, unit);
return promise;
}
public static void main(String[] args) {
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
// 异步任务逻辑
// 此处仅作示例,可以是任何耗时的操作
try {
TimeUnit.SECONDS.sleep(5); // 模拟一个长时间的任务
} catch (InterruptedException e) {
e.printStackTrace();
}
return "Async result";
});
CompletableFuture<String> resultFuture = completeOnTimeout("Default result", 3, TimeUnit.SECONDS);
future.acceptEither(resultFuture, System.out::println);
// 等待异步任务完成
try {
future.get(); // 这会阻塞直到任务完成
} catch (Exception e) {
e.printStackTrace();
} finally {
scheduler.shutdown();
}
}
}