用反应堆发射并忘记

Question

我的 Spring 启动应用程序中有如下方法。

public Flux<Data> search(SearchRequest request) {
  Flux<Data> result = searchService.search(request);//this returns Flux<Data>
  Mono<List<Data>> listOfData = result.collectList();
//  doThisAsync() // here I want to pass this list and run some processing on it
// the processing should happen async and the search method should return immediately.
  return result;
}

//this method uses the complete List<Data> returned by above method
public void doThisAsync(List<Data> data) {
  //do some processing here
}

目前，我正在使用@Async注释服务 class 和doThisAsync ，但不知道如何传递List<Data> ，因为我不想调用block 。 我只有Mono<List<Data>> 。

我的主要问题是如何单独处理这个 Mono 并且search方法应该返回Flux<Data> 。

Answer 1

1，如果你的即发即忘已经异步返回Mono / Flux

public Flux<Data> search(SearchRequest request)
{
    return searchService.search(request)
                        .collectList()
                        .doOnNext(data -> doThisAsync(data).subscribe())  // add error logging here or inside doThisAsync
                        .flatMapMany(Flux::fromIterable);
}

public Mono<Void> doThisAsync(List<Data> data) {
    //do some async/non-blocking processing here like calling WebClient
}

2、如果你的即发即忘确实阻塞了I/O

public Flux<Data> search(SearchRequest request)
{
    return searchService.search(request)
                        .collectList()
                        .doOnNext(data -> Mono.fromRunnable(() -> doThisAsync(data))
                                              .subscribeOn(Schedulers.elastic())  // delegate to proper thread to not block main flow
                                              .subscribe())  // add error logging here or inside doThisAsync
                        .flatMapMany(Flux::fromIterable);
}

public void doThisAsync(List<Data> data) {
    //do some blocking I/O on calling thread
}

请注意，在上述两种情况下，您都失去了背压支持。 如果doAsyncThis由于某种原因变慢，那么数据生产者不会关心并继续生产项目。 这是火与雾机制的自然结果。

Answer 2

您是否考虑过使用如下示例中的 publishOn 在单独的线程中运行处理？ 这可能不是您所要求的，但允许您继续处理其他事项，同时处理通量中的结果由一个或多个线程完成，在我的示例中为四个，来自专用调度程序 (theFourThreadScheduler)。

    @Test
    public void processingInSeparateThreadTest() {
        final Scheduler theFourThreadScheduler = Schedulers.newParallel("FourThreads", 4);
        final Flux<String> theResultFlux = Flux.just("one", "two", "three", "four", "five", "six", "seven", "eight");

        theResultFlux.log()
            .collectList()
            .publishOn(theFourThreadScheduler)
            .subscribe(theStringList -> {
                doThisAsync(theStringList);
            });

        System.out.println("Subscribed to the result flux");

        for (int i = 0; i < 20; i++) {
            System.out.println("Waiting for completion: " + i);
            try {
                Thread.sleep(300);
            } catch (final InterruptedException theException) {
            }
        }
    }

    private void doThisAsync(final List<String> inStringList) {
        for (final String theString : inStringList) {
            System.out.println("Processing in doThisAsync: " + theString);
            try {
                Thread.sleep(500);
            } catch (final InterruptedException theException) {
            }
        }
    }

运行该示例会产生以下输出，表明 doThisAsync() 中执行的处理是在后台执行的。

Subscribed to the result flux
Waiting for completion: 0
Processing in doThisAsync: one
Waiting for completion: 1
Processing in doThisAsync: two
Waiting for completion: 2
Waiting for completion: 3
Processing in doThisAsync: three
Waiting for completion: 4
Waiting for completion: 5
Processing in doThisAsync: four
Waiting for completion: 6
Processing in doThisAsync: five
Waiting for completion: 7
Waiting for completion: 8
Processing in doThisAsync: six
Waiting for completion: 9
Processing in doThisAsync: seven
Waiting for completion: 10
Waiting for completion: 11
Processing in doThisAsync: eight
Waiting for completion: 12
Waiting for completion: 13
Waiting for completion: 14
Waiting for completion: 15
Waiting for completion: 16
Waiting for completion: 17
Waiting for completion: 18
Waiting for completion: 19

参考资料： Reactor 3 参考资料：调度程序

Answer 3

更新 2023/01/31

实际上你无论如何都应该使用.subscribeOn()因为即使你调用你的fire-and-forget function 返回Mono<Void>也不能保证在那个反应链中会切换执行线程或者它会立即发生（取决于即发即弃 function 中的代码，更具体地说，是在链上使用的运算符）。

因此，您可能会遇到这样的情况：即发即弃 function 将在调用此 function 的同一线程上执行，因此您的方法将不会返回，直到此 function 完成。

即发即弃 function 返回Publisher<Void>的情况：

public Flux<Data> search(SearchRequest request) {
    return searchService.search(request)
            .collectList()
            .doOnNext(data ->
                    // anyway call subscribeOn(...)
                    fireAndForgetOperation(data)
                            .subscribeOn(...)
                            .subscribe()
            )
            .flatMapMany(Flux::fromIterable);
}

public Mono<Void> fireAndForgetOperation(List<String> list) {
    ...
}

即发即弃 function 只是一种常见的void返回方法的情况：

public Flux<Data> search(SearchRequest request) {
    return searchService.search(request)
            .collectList()
            .doOnNext(data ->
                    Mono.fromRunnable(() -> fireAndForgetOperation(data))
                            .subscribeOn(...)
                            .subscribe()
            )
            .flatMapMany(Flux::fromIterable);
}

public void fireAndForgetOperation(List<String> list) {
    ...
}

您还应该考虑需要提供什么Scheduler ，具体取决于即发即弃 function 的性质。

基本上有两种情况：

1)如果你的即发即弃 function 做CPU-Bound工作。 然后你想在subsribeOn()中指定Schedulers.parallel() )

2）如果你的即发即弃 function 确实IO工作（实际上无论在这种情况下它是阻塞还是非阻塞 IO）。 然后你想在subsribeOn()中指定Schedulers.boundedElastic() )

因此，使用这种方法，您将真正在触发即发即弃 function 后立即返回