在RxJava流中添加线程池

我想知道是否可以使用RxJava库在以下用例中添加一些并发性：

• 从现有的

  结果集

  中，使用自定义的

  可观察的

  （类似于

  ResultSetObservable.create（ResultSet）

  ）顺序获取

  字符串

  列
• 为这些值中的每一个调用Web服务（例如，使用

  InvokeWebServiceFunc1（）

  实例），以检索与

  字符串

  相关的一些统计信息（注意

  对

  中的

  字符串

  与输入中传递的字符串相同）
• 以CSV格式打印所有内容（使用

  ExportAsCSVAction1（PrintStream PrintStream）

  ）

这就是我所拥有的：

ResultSetObservable.create(resultSet)
    .map(new InvokeWebServiceFunc1<String, Pair<String, Integer>>())
    .subscribe(new ExportAsCSVAction1<Pair<String, Integer>>(System.out));

ResultSetObservable.create（resultSet）
.map（新的InvokeWebServiceFunc1（））
.订阅（新的ExportAsCSVAction1（System.out））；

它工作得很好，但由于Web服务可能需要一些时间来处理一些

字符串

输入，我想通过为映射（例如10个线程）提供类似线程池的行为来添加一些并发性，但我需要在同一个线程中调用

ExportAsCSVAction0

（实际上，当前线程将是完美的）

您能帮助我吗？我不知道在这里使用

toBlocking（）.forEach（）

模式是否是正确的解决方案，我不知道在哪里使用

调度程序。从（fixedThreadPool）

（在

observeOn（）

中或在

subscribeOn（）

中）

谢谢你的帮助！

我自己找到的

package radium.rx;

import java.util.List;
import java.util.Arrays;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import rx.Observable;
import rx.schedulers.Schedulers;

public class TryRx {

    public static Random RANDOM = new Random();

    public static void main(String[] arguments) throws Throwable {
        final List<Integer> inputs = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
        final ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(2);

        Iterable<Integer> outputs = Observable.<Integer>from(inputs)
                .flatMap((Integer input) -> deferHeavyWeightStuff(input).subscribeOn(Schedulers.from(threadPoolExecutor)))
                .toBlocking()
            .toIterable();

        for (Integer output : outputs) {
            System.out.println(output);
        }

        threadPoolExecutor.shutdown();
    }

    public static void sleepQuietly(int duration, TimeUnit unit) {
        try {
            Thread.sleep(unit.toMillis(duration));
        } catch (InterruptedException e) {

        }
    }

    public static Observable<Integer> deferHeavyWeightStuff(final int input) {
        return Observable.defer(() -> Observable.just(doHeavyWeightStuff(input)));
    }

    public static int randomInt(int min, int max) {
        return RANDOM.nextInt((max - min) + 1) + min;
    }

    public static int doHeavyWeightStuff(int input) {
        sleepQuietly(randomInt(1, 5), TimeUnit.SECONDS);
        int output = (int) Math.pow(input, 2);
        return output;
    }

}

package radium.rx；
导入java.util.List；
导入java.util.array；
导入java.util.Random；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.TimeUnit；
进口接收。可观察；
导入rx.schedulers.schedulers；
公共类TryRx{
公共静态随机=新随机（）；
公共静态void main（字符串[]参数）抛出Throwable{
最终列表输入=Arrays.asList（1,2,3,4,5,6,7,8,9,10,11,12）；
final ExecutorService threadPoolExecutor=Executors.newFixedThreadPool（2）；
可观测的输出=可观测的（输入）
.flatMap（（整数输入）->延迟重量级Tuff（输入）.subscribeOn（调度程序.from（threadPoolExecutor）））
.toBlocking（）
.toIterable（）；
用于（整数输出：输出）{
系统输出打印项次（输出）；
}
threadPoolExecutor.shutdown（）；
}
公共静态无效（整数持续时间，时间单位）{
试一试{
睡眠（单位为托米利（持续时间））；
}捕捉（中断异常e）{
}
}
公共静态可观测延迟重量级凝灰岩（最终整数输入）{
返回可观察的。延迟（（）->可观察的。刚刚（DoHeavweightsTuff（输入））；
}
公共静态int randomInt（int最小值，int最大值）{
返回RANDOM.nextInt（（max-min）+1）+min；
}
公共静态整数权重凝灰岩（整数输入）{
安静睡眠（随机点（1，5），时间单位。秒）；
int输出=（int）Math.pow（输入，2）；
返回输出；
}
}

---

干杯！

非常感谢。但是，输出的顺序似乎与输入的顺序不同。有没有关于如何修复它的线索。这是并行化时需要的。请参阅随机睡眠时间函数