parallel call using rxjava 1 - java-8

Question

Scenario - To make a service call for certain items (suppose 4 items) which will update DB. Sequence doesn't matter. All service calls are independent of each other but wait till all the calls are completed, so want to go for parallel calls using rxjava 1.x
Now, the problem that I'm facing is update service doesn't return anything if it is successful.
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
});
}

Answer 1

Note that RxJava 1 is outdated and no longer supported or maintained as a library.
You can flatMap each map element onto its own reactive action to have them run concurrently:
Observable.from(map.entrySet())
.flatMap(entry ->
Observable.create(emitter -> {
dbClient.update(entry.getValue());
emitter.onCompleted();
})
.subscribeOn(Schedulers.io()),
true, // <------------ aggregate all errors
8 // <---------------- number of concurrent updates you want
)

Answer 2

You can use flatMap operator for parallel executing. Create List<Observable> using map and then executes them using Observable.flatMap. Focus on it.subscribeOn line. The line changes sequence to parallel.
Refer to here
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);
}
}
Output
4
1
2
3