如何从中间拆除RxJava 2链（并释放资源）？

Question

从中间即从ObservableTransformer断开RxJava2链的推荐方法是什么？

我是说要撕毁

• 向上游发送dispose，
• 向下游发送onComplete，并且
• 清理所有本地资源。

下面是设置的快速草图。请注意，它似乎几乎可以正常工作，但是下游没有收到onComplete。

package rx;

import io.reactivex.functions.Function;
import io.reactivex.Observable;
import io.reactivex.Emitter;
import io.reactivex.schedulers.Schedulers;
import io.reactivex.ObservableTransformer;
import java.util.concurrent.atomic.AtomicBoolean;

import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.disposables.Disposable;

import java.util.concurrent.TimeUnit;

public class StatefulProcessor {
    public static void main(String[] args) {

    Observable<Long> src =
        Observable.interval(1000L, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.newThread());
    Observable<Long> srcExtra =
        Observable.interval(200L, TimeUnit.MILLISECONDS).subscribeOn(Schedulers.newThread());

    Processor proc = new Processor(700L);

    Disposable d =
    src
        .doOnDispose(() -> { System.out.println("Src DISPOSED!"); })
        .compose(proc.process())
        .observeOn(Schedulers.newThread())
        .subscribe(x -> { System.out.println("Src: " + x); },
                   e -> { },
                   () -> { System.out.println("Src CONSUMER onComplete()!"); });

    Disposable dExtra =
    srcExtra
        .doOnDispose(() -> { System.out.println("SrcExtra DISPOSED!"); })
        .compose(proc.process())
        .observeOn(Schedulers.newThread())
        .subscribe(x -> { System.out.println("SrcExtra: " + x); },
                   e -> { },
                   () -> { System.out.println("SrcExtra CONSUMER onComplete()!"); });

    // pause & destroy                                                                                                                                                                                                                                                         
    sleep(2000);
    //d.dispose();                                                                                                                                                                                                                                                             

    sleep(2000);
    proc.release();


    // vait long enough                                                                                                                                                                                                                                                        
    sleep(100000);
}

static void sleep(long millis) {
    try {
        Thread.sleep(millis);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

static class Resource {
    Long cnt = null;
    Resource() {}
    void setup(Long l) {
        cnt = l;
        System.out.println("[Processor] setup!");
    }
   Long value() {
        cnt += 1;
        return cnt;
    }
    void teardown() {
        cnt = null;
        System.out.println("[Processor] teardown!");
    }
}

static class Processor {
    private static final CompositeDisposable disp = new CompositeDisposable();
    Resource r = null;

    AtomicBoolean gate = new AtomicBoolean(false);
    Processor(Long x) {
        r = new Resource();
        r.setup(x);
    }
    void release() {
        // cannot release resource yet,                                                                                                                                                                                                                                        
        // there might be an item flying down the chain!                                                                                                                                                                                                                       
        // r.teardown(); // <== this throws!                                                                                                                                                                                                                                   
        disp.dispose();
        gate.set(true);
        r.teardown();
    }

    ObservableTransformer<Long, Long> process() {
        return upstream -> {
                return upstream.doOnSubscribe(disp::add).takeUntil((Long __) -> gate.get()).observeOn(Schedulers.newThread()).map(__ -> r.value());
            };
        }

    }

}

请注意，跨链共享状态/资源是有意的。输出是以下

[Processor] setup!
SrcExtra: 701
SrcExtra: 702
SrcExtra: 703
SrcExtra: 704
Src: 705
SrcExtra: 706
SrcExtra: 707
SrcExtra: 708
SrcExtra: 709
SrcExtra: 710
Src: 711
SrcExtra: 712
SrcExtra: 713
SrcExtra: 714
SrcExtra: 715
SrcExtra: 716
Src: 717
SrcExtra: 718
SrcExtra: 719
SrcExtra: 720
SrcExtra: 721
SrcExtra: 722
Src: 723
SrcExtra: 724
SrcExtra DISPOSED!
Src DISPOSED!
[Processor] teardown!