Java 8 使用rxjava1的并行调用

场景-为某些项（假设4项）进行服务调用，这将更新数据库。顺序不重要。所有服务调用都是相互独立的，但要等到所有调用都完成，所以要使用rxjava1.x进行并行调用吗

现在，我面临的问题是，如果更新服务成功，它不会返回任何内容

public class DbClient {
  public void update(SomeObject someObject) {
  //update logic
  }
}

//client code to call update method

public void processUpdate(Map<String, SomeObject> map) {
 map.entrySet.stream.forEach(entry -> {
    dbClient.update(entry.getValue()); // how can I call this parallely using rxjava 1.x
    });
}

公共类DbClient{
公共无效更新（SomeObject SomeObject）{
//更新逻辑
}
}
//调用更新方法的客户端代码
公共void进程更新（映射）{
map.entrySet.stream.forEach（条目->{
dbClient.update（entry.getValue（））；//如何使用rxjava 1.x并行调用此函数
});
}

请注意，RxJava 1已经过时，不再作为库支持或维护

您可以

flatMap

将每个映射元素映射到其自己的反应动作上，以使它们同时运行：

Observable.from（map.entrySet（））
.flatMap（条目->
可观察。创建（发射器->{
dbClient.update（entry.getValue（））；
emitter.onCompleted（）；
})
.subscribeOn（Schedulers.io（）），
是的，//您可以使用
flatMap
操作符来并行执行。使用
map
创建
列表
，然后使用
Observable.flatMap
执行它们。关注
it.subscribeOn
行。行将序列更改为并行

指

感谢您的回答。我一定会尝试这种方法。目前，我使用Completable.fromAction（）实现了并行调用。但您的方法似乎更简洁：）您不应该在计算计划程序上执行阻塞调用。同样的
fromIterable
在2.x中，这个问题是基于1.x的。
public class MultipleExecutes {
    public class DbClient {
        Observable<String> update(String someObject) {
            // replace what you want.
            // Observable.fromCallable() <- consider this
            return Observable.just(someObject);
        }
    }

    // client code to call update method
    private List<Observable<String>> processUpdate(Map<String, String> map) {
        DbClient dbClient = new DbClient();

        return map
                .entrySet()
                .stream()
                .map(entry -> dbClient.update(entry.getValue()))
                .collect(Collectors.toList());
    }

    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("1", "1");
        map.put("2", "2");
        map.put("3", "3");
        map.put("4", "4");

        List<Observable<String>> o = new MultipleExecutes().processUpdate(map);
        Observable
                .fromIterable(o)
                .flatMap(it -> it.subscribeOn(Schedulers.computation())) <-- important line
                .subscribe(System.out::println);

        Thread.sleep(500);
    }
}


4
1
2
3