Single.subscribeWith is not disposed

Rxjava version:

compile "io.reactivex.rxjava2:rxjava:2.1.6"

Example:

Disposable disposable = Single.just("123")
        .subscribeWith(new DisposableSingleObserver() {
            @Override
            public void onSuccess(Object o) {}

            @Override
            public void onError(Throwable e) {}
        });

System.out.println("Disposed: "  + disposable.isDisposed());

Output:

Disposed: false

Expected result: Disposable should be disposed.

Related issues:

• #5160 : 2.x: Disposable returned from Single.subscribe() is not disposed after terminal event
• #5276 : Single’s Disposable is not disposing

[akarnokd]

Since DisposableSingleObserver implements the SingleObserver interface as abstract methods, it can’t call dispose() for you and you have to call that from within onSuccess or onComplete. Therefore, you can either call the lambda subscribe() overload and get the isDisposed consistent with the state or define your abstract wrapper over DisposableSingleObserver.

In concept, once onSuccess or onError are called, the upstream is to be considered disposed thus there should be no reason to call dispose at that point. People often need side-effects when a source terminates or gets disposed, thus they use doOnDisposed and call dispose from onSuccess to trigger that cleanup. However, there is a more appropriate operator called doFinally that executes after terminal events or dispose calls, thus you don’t have to call dispose to cleanup a flow.

ResourceSingleObserver’s JavaDoc explains it a bit better though.

[akarnokd]

Upstream’s don’t care if your SingleObserver implements Disposable because unlike 1.x, dispose() travels upstream and never downstream. If a chain has resources, a terminal event will free those resources so you don’t have to call dispose. just has no resources associated.

The convenience observer classes, such as DisposableSingleObserver are provided so one can call dispose on it from any thread without the need to dig into the concurrency implications of such call.

isDisposed makes only sense on container types and inside operators that check if they should continue producing data or not.

Checking if a flow has terminated via isDisposed has two discouraged uses: trying to sleep-loop or busy-loop on it or having a completely synchronous flows that terminates once the execution returns from subscribe(). You have the latter case.

The DisposableSingleObserver keeps two abstract methods, onSuccess and onError from SingleObserver. You implement those methods and Single talks to the SingleObserver interface. There is nothing in between that would react to the method calls and make isDisposed return true - we don’t use aspect oriented programming in RxJava after all.

So either don’t rely on isDisposed or write another wrapper that implements onSuccess and onError, delegates some alternative abstract methods and then calls dispose() for you to get isDisposed return true:

public abstract class AbstractMySingleObserver<T> extends DisposableSingleObserver<T> {

    @Override
    public final void onSuccess(T item) {
        try {
            success(item);
        } finally {
            dispose();
        }
    }

    @Override
    public final void onError(Throwable ex) {
        try {
            error(ex);
        } finally {
            dispose();
        }
    }

    protected abstract void success(T item);

    protected abstract void error(Throwable ex);

}