RxJava等效于简单ThreadPoolExecutor示例

Question

我已经退出Java游戏大约8年了，从那以后发生了很多变化。对我来说最大的挑战是RxJava/反应式。我正在寻找关于如何以完全反应式的方式执行以下等效操作的粗略指导。

下面使用ThreadPoolExecutor实现的基本需求是通过调用远程web服务来处理大量的内容，该服务的记录速率限制为每分钟100个请求。我的目标是尽可能快地处理，不丢弃任何东西，但仍然遵守下游利率限制。该代码已被简化，以避免错误、舱壁、断路器、重试逻辑等。

这段代码目前运行良好，但考虑到所有非阻塞的被动选项，它会导致大量的线程浪费。甚至我用来调用我的服务的HTTP客户端也提供了一个可流动的，我只是在执行器的20个线程中的每个线程中阻塞它。

我很想了解反应当量应该是什么。我所遇到的困难是，我找到的showcase中几乎所有的文档都使用静态源作为可观察对象（例如：从数组（1,2,3,4,5））。我知道解决方案可能涉及IoScheduler，也可能涉及groupBy，但我还没有弄清楚如何将来自HTTP客户端的可流动的代码合并到一个完整的链中，该链可以进行并行化（最多20个）和速率限制。

public class Example {
    private static final int THREADS = 20;

    // using https://docs.micronaut.io/latest/guide/index.html#httpClient
    @Client("http://stuff-processor.internal:8080")
    @Inject
    RxHttpClient httpClient;

    private ThreadPoolExecutor executor;
    private final RateLimiter rateLimiter;

    public Example() {
        // up to 20 threads to process the unbounded queue
        // incoming Stuff is very bursty...
        // ...we could go hours without anything and then hundreds could come in
        this.executor = new ThreadPoolExecutor(THREADS, THREADS,
                30,TimeUnit.SECONDS, new LinkedBlockingQueue<>());
        this.executor.allowCoreThreadTimeOut(true);

        // using https://resilience4j.readme.io/docs/ratelimiter
        RateLimiterConfig config = RateLimiterConfig.custom()
                .limitRefreshPeriod(Duration.ofSeconds(60))
                .limitForPeriod(100)
                .timeoutDuration(Duration.ofSeconds(90))
                .build();
        RateLimiterRegistry rateLimiterRegistry = RateLimiterRegistry.of(config);
        rateLimiter = rateLimiterRegistry.rateLimiter("stuff-processor", config);
    }

    /**
     * Called when the user takes an action that can cause 1 or 1000s of new
     * Stuff to be entered into the system. Each instance of Stuff results in
     * a separate call to this method. Ex: 100 Stuffs = 100 calls.
     */
    void onNewStuff(Stuff stuff) {
        final Runnable task = () -> {
            final Flowable<HttpResponse<Boolean>> flowable = httpClient.exchange(
                    HttpRequest.POST("/process", stuff),
                    Boolean.class);

            final HttpResponse<Boolean> response = flowable.blockingFirst();
            if (response.body()) {
                System.out.println("Success!");
            } else {
                System.out.println("Fail :(");
            }
        };

        final Runnable rateLimitedTask = 
                RateLimiter.decorateRunnable(rateLimiter, task);
        executor.submit(rateLimitedTask);
    }
}

谢谢你！

Answer 1

首先，要以完全非阻塞的方式构建它，您需要使用像Netty这样的非阻塞、异步HTTP客户端库。我不确定RxHttpClient是如何工作的。

假设你有一个清单。我会这样做：

Observable.fromIterable(stuffs).flatMap(a -> client.nonBlockingPost(a).subscribeOn(Schedulers.io())).subscribe();

flatMap在响应出现时将其合并。

为了限制速率，您平面地图有第二个参数，它限制它并行订阅的内部流的数量。假设您想一次进行不超过10次调用。这样做：

Observable.fromIterable(stuffs).flatMap(a -> client.nonBlockingPost(a).subscribeOn(Schedulers.io()), 10).subscribe();