Observable.just（doSomeLongStuff（））在我订阅observable之前先运行doSomeLongStuff（）

Question

I have stupid problem with RxJava2.

I need to run two long operations at the same time. I know that I should use Observable.zip() and I use it.

The problem, that my long operations is run one after another and another problem that my long operations starting before I subscribe to them.

Let's imagine that this is my long operation that I should run async.

private String doSomethingLong() {
        Random rand = new Random();
        int value = rand.nextInt(5);
        Timber.i("Do something for [%d] sec [%s]", value, Thread.currentThread().getName());
        try {
            Thread.sleep(value * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
            return String.format(Locale.getDefault(), "Exception [%s]", e.getMessage());
        }
        return String.format(Locale.getDefault(),"Job for [%d] seconds", value);
    }

And let there is a method like test() that will try to make it parallel:

public void test() {

        final long started = System.currentTimeMillis();
        Observable<String> just1 = Observable.just(doSomethingLong()).subscribeOn(Schedulers.newThread());
        Observable<String> just2 = Observable.just(doSomethingLong()).subscribeOn(Schedulers.newThread());


        Observable.zip(just1, just2, new Func2<String, String, Combined>() {
            @Override
            public Combined call(String s, String s2) {
                return new Combined(s, s2);
            }
        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Combined>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Combined combined) {
                long total = System.currentTimeMillis() - started;
                Timber.i("TOTAL [%d]ms [%s]", total, combined.toString());
            }
        });

    }

When I'm trying to run this I observe that two observables just1 and just2 runs one after another... And it's confused me...

But there is another staff that confused me more... I commented Observable.zip and noticed that just1 and just2 started method doSomethingLong() before I subscribed to them...

Let me show:

public void test() {

        final long started = System.currentTimeMillis();
        Observable<String> just1 = Observable.just(doSomethingLong()).subscribeOn(Schedulers.newThread());
        Observable<String> just2 = Observable.just(doSomethingLong()).subscribeOn(Schedulers.newThread());


//        Observable.zip(just1, just2, new Func2<String, String, Combined>() {
//            @Override
//            public Combined call(String s, String s2) {
//                return new Combined(s, s2);
//            }
//        }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<Combined>() {
//            @Override
//            public void onCompleted() {
//
//            }
//
//            @Override
//            public void onError(Throwable e) {
//
//            }
//
//            @Override
//            public void onNext(Combined combined) {
//                long total = System.currentTimeMillis() - started;
//                Timber.i("TOTAL [%d]ms [%s]", total, combined.toString());
//            }
//        });

    }

This code make almost same - it's run two times doSomethingLong() one after another...

What I'm expect: 1. I need that doSomethingLong() methods run parallel 2. I'm asking to explain why those methods runs before I start subscribe them. 3. How should I write me code well in this situation. I want that doSomethingLong() methods do not called before I subscribe to them.

Thanks a lot. Hope that I explain problem well.

Answer 1

Observable.just doesn't run anything when you subscribe. It emits the elements when you subscribe, but your doSomethingLong will run as soon as you pass it as an argument. That's normal and it's how the language works.

What you're looking for is a way to say return this when we subscribe, but also only run it at that time and hopefully on a background thread.

There are a couple of answers for this, here are some:

Using defer

There's an operator called defer which takes a lambda which will be executed once you subscribe:

Observable.defer(() ->  doSomethingLong())

This will only execute doSomethingLong when you subscribe

Using fromCallable

You can create an observable from a lambda. This is known as fromCallable :

Observable.fromCallable(() -> doSomethingLong())

Similarly, this will only run doSomethingLong when you subscribe

Using create

I think this is perhaps the most discouraged way of doing it, since there's a couple of things you have to deal with, but I think for the she of completeness it's ok to mention:

Observable.create( emitter -> {
    if(emitter.isDisposed()) return;

    emitter.onNext(doSomethingLong());
    emitter.onComplete();
});

Again, I'm sure there's more ways of doing this. I just wanted to explain the issue and give some options.

Answer 2

Create your Observables as Observable.fromCallable{}. And instead of zip use combineLatest()

Docs: http://reactivex.io/RxJava/javadoc/io/reactivex/Observable.html#fromCallable-java.util.concurrent.Callable- http://reactivex.io/documentation/operators/combinelatest.html