如何使多线程观察者计算速率适应冷的Observable <List<T> &gt;

Question

我有一个Source作为冷Observable<List<T>> ，它以块（列表）形式发射元素，我想在单独的线程中处理块中的每个项目，而发射器（源）正在等待终止处理发出的块中的所有项目都将继续进行下一个，依此类推。

这段代码（rxjava 2.0.6）仅在一个线程中执行此操作。 如果我想使用observeOn(Schedulers.io)将观察者计算分叉到多个线程中，则源线程将继续发出所有内容，直到完成为止，并且不会被每个块阻塞。

Observable<List<T>> lazy_source = Observable.create((ObservableEmitter<List<T>> e)
        -> {
    for (int i = 0; i < 1000; i++) {
        List<T> chunk = produceChunkOf(10);
        e.onNext(chunk);
    }

    e.onComplete();
});    
lazy_source
        .subscribeOn(Schedulers.io())
        .flatMap(chunk -> 
                Observable.fromIterable(chunk)
                    // .observeOn(Schedulers.io()) // Uncommenting this will flat all 1000 chunks at once.
                    .doOnNext(item -> consume(item))
                , 10) // Number of concurent Threads
        .subscribe();

我将不胜感激。

Answer 1

这样的事情怎么样：

 Observable.range(0, 1000)
            .concatMap(new Func1<Integer, Observable<?>>() {
                @Override
                public Observable<?> call(Integer integer) {
                    return produceChunkOf(10)
                            .flatMap(new Func1<Object, Observable<?>>() {
                                @Override
                                public Observable<?> call(Object item) {
                                    return consume(item)
                                            .observeOn(Schedulers.io());
                                }
                            }, 10)
                            .toList();
                }
            });

首先，创建一个Observable ，将其发出到produceChunkOf的输入，然后对于每个输入项，使用concatMap来满足对每个块的顺序执行的要求，对于每个输入，您concatMap生成块，并与flatMap并行处理，然后收集使用toList（）处理所有项目之后

Answer 2

这是最终版本（无开销）：

Observable.range(0, 1_000_000)
        .subscribeOn(Schedulers.io())
        .concatMap(i -> produceChunkOf(100) // this returs an Observable of 100 items
                .flatMap(item -> Observable
                        .just(item)
                        .observeOn(Schedulers.io())
                        .doOnNext(element -> consume(element)), 
                        50)) // Number of concurent Threads
        .subscribe();