Question

我正面临一个与combineLatest相关的棘手问题。我正在构建一个巨大的combineLatest链，从我的主要观察者的第二个项目开始，计算的爆炸性增长。

import org.testng.annotations.Test;
import rx.Observable;
import rx.observers.TestSubscriber;
import rx.subjects.PublishSubject;
import rx.subjects.Subject;

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class RxTest {

    private AtomicInteger ai = new AtomicInteger(0);
    private AtomicInteger ai2 = new AtomicInteger(0);

    @Test
    public void explosion() {
        Subject<Integer, Integer> sub = PublishSubject.create();
        Observable<Integer> ret = getObservable(2, sub);

        TestSubscriber<Integer> testSubscriber = new TestSubscriber<Integer>();
        ret.subscribe(testSubscriber);

        sub.onNext(1);
        sub.onNext(2); // may be commented
        sub.onCompleted();

        testSubscriber.assertNoErrors();

        List<Integer> numbers = testSubscriber.getOnNextEvents();

        System.out.println(numbers.size());
        System.out.println(ai);
        System.out.println(ai2);
    }

    private Observable<Integer> getObservable(int depth, Observable<Integer> source) {
        if (depth == 0) {
            return source;
        } else {
            Observable<Integer> o = getObservable(depth - 1, source);
            for (int i = 0; i < 300; ++i) {
                ai2.incrementAndGet();
                o = Observable.combineLatest(
                        o,
                        getObservable(depth - 1, source).map((a) -> {
                            ai.incrementAndGet();
                            return a;
                        }),
                        (a, b) -> a + b
                );
            }
            return o;
        }
    }
}

只有一个项目，我有：

1
90600
90600

有两个：

90602 
271200
90600

这似乎是RX的正常行为。但我想知道是否有可能避免这种爆炸。我的目标是拥有这种输出（比如为每个值重新创建链）

2 
181200
90600

此代码是我的问题的一个例子，而不是真实的用例。

我面临的事实是构建observable是快速的（并且具有来自observable的第一个值），但是如果我正在改变“leaf”可观察的，那么它不是。

由于

RxJava计算爆炸

0 个答案: