RxJava and parallel execution of observer code

Question

I am having the following code using RxJava Observable api :

Observable observable = fileProcessor.processFileObservable(processedFile.getAbsolut         


        

Answer 1

Using flatMap and specify to subscribe on Schedulers.computation() will achieve concurrency.

Here is a more practical example using Callable, from the output, we can see it will take about 2000 milliseconds to finish all the tasks.

static class MyCallable implements Callable {

    private static final Object CALLABLE_COUNT_LOCK = new Object();
    private static int callableCount;

    @Override
    public Integer call() throws Exception {
        Thread.sleep(2000);
        synchronized (CALLABLE_COUNT_LOCK) {
            return callableCount++;
        }
    }

    public static int getCallableCount() {
        synchronized (CALLABLE_COUNT_LOCK) {
            return callableCount;
        }
    }
}

private static void runMyCallableConcurrentlyWithRxJava() {
    long startTimeMillis = System.currentTimeMillis();

    final Semaphore semaphore = new Semaphore(1);
    try {
        semaphore.acquire();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    Observable.just(new MyCallable(), new MyCallable(), new MyCallable(), new MyCallable())
            .flatMap(new Function>() {
                @Override
                public ObservableSource apply(@NonNull MyCallable myCallable) throws Exception {
                    return Observable.fromCallable(myCallable).subscribeOn(Schedulers.computation());
                }
            })
            .subscribeOn(Schedulers.computation())
            .subscribe(new Observer