Question

有人可以告诉我有没有办法使用Spring Framework的@Async注释而不阻塞/等待结果？以下是一些代码来澄清我的问题：

@Service
public class AsyncServiceA {

    @Autowired
    private AsyncServiceB asyncServiceB;

    @Async
    public CompletableFuture<String> a() {
        ThreadUtil.silentSleep(1000);
        return asyncServiceB.b();
    }
}


@Service
public class AsyncServiceB {

    @Async
    public CompletableFuture<String> b() {
        ThreadUtil.silentSleep(1000);
        return CompletableFuture.completedFuture("Yeah, I come from another thread.");
    }
}

和配置：

@SpringBootApplication
@EnableAsync
public class Application implements AsyncConfigurer {

    private static final Log LOG = LogFactory.getLog(Application.class);

    private static final int THREAD_POOL_SIZE = 1;

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Bean
    public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
        return args -> {
            final AsyncServiceA bean = ctx.getBean(AsyncServiceA.class);
            bean.a().whenComplete(LOG::info);
        };
    }

    @Override
    @Bean(destroyMethod = "shutdown")
    public ThreadPoolTaskExecutor getAsyncExecutor() {
        final ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(THREAD_POOL_SIZE);
        executor.setMaxPoolSize(THREAD_POOL_SIZE);
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        // omitted
    }
}

当我运行应用程序时，执行程序通过调用AsyncServiceA.a()并离开，但它仍然保持池中的线程等待CompletableFuture.get()方法。由于池中只有一个线程，因此AsyncServiceB.b()无法执行。我期待的是，线程在执行AsyncServiceA.a()后返回池中，然后可用于执行AsyncServiceB.b()。

有办法吗？

注1：我也试过了ListenableFuture，但结果是一样的。

注意2：我已经成功手动完成（没有@Async），只需给每个方法执行一次执行程序：

AsyncServiceA

public CompletableFuture<String> manualA(Executor executor) {
    return CompletableFuture.runAsync(() -> {
        LOG.info("manualA() working...");
        ThreadUtil.silentSleep(1000);
    }, executor)
            .thenCompose(x -> asyncServiceB.manualB(executor));
}

AsyncServiceB

public CompletableFuture<String> manualB(Executor executor) {
    return CompletableFuture.runAsync(() -> {
        LOG.info("manualB() working...");
        ThreadUtil.silentSleep(1000);
    }, executor)
            .thenCompose(x -> CompletableFuture
                    .supplyAsync(() -> "Yeah, I come from another thread.", executor));
}

如果有人想知道，这是ThreadUtil。

public class ThreadUtil {

    public static void silentSleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

更新：为非阻止异步注释添加了问题https://jira.spring.io/browse/SPR-15401

Answer 1

自{Spring} 3.0以来，@Async支持已经成为Spring的一部分，这是Java8（或者说是7）存在之前的方式。虽然在以后的版本中为CompletableFuture添加了支持，但它仍然用于方法调用的简单异步执行。（initial implementation反映/显示通话）。

对于编写回调和操作非阻塞，异步支持从未被设计或打算用于。

对于非阻塞支持，您可能希望等待Spring 5及其响应/非阻塞核心，旁边您始终可以submit a ticket在异步支持中获得非阻塞支持。

Answer 2

我已经对机票https://jira.spring.io/browse/SPR-15401做出了回复，但我也会在这里做出回应，以确定M. Deinum的回复资格。

@Async凭借其工作原理（通过AOP修改方法调用）只能做一件事，即将整个方法从同步变为异步。这意味着该方法必须是同步的，而不是同步和异步的混合。

所以ServiceA做一些休眠，然后委托给异步ServiceB，必须将休眠部分包装在某些@Async ServiceC中，然后在ServiceB和C上进行组合。这样ServiceA就变成了异步，不需要@Async注释本身..

Spring异步阻塞并阻止嵌套的异步调用

2 个答案: