Question

我想知道我是否可以在Observables和io()计划程序上产生100万个computation()。

 public static void observableLimit() {
        sum = 0;
        long lowerBound = 0;
        long higherBound = 1000;
        Flowable.fromCallable(() -> {
            Flowable.rangeLong(lowerBound, higherBound + 1)
                    .subscribe(integer -> Observable.just(integer)
                            .subscribeOn(Schedulers.io())
                            .subscribe(j -> {
                                printNum(j);
                                sum = sum + j;
                            }));
            return true;
        }).blockingSubscribe(aBoolean -> {
            long actualSum = (higherBound * (higherBound + 1)) / 2;
            System.out.println("");
            System.out.println("SUM: " + sum);
            Assert.assertEquals(actualSum, sum);
        });
    }

higherBound = 100对于newThread()大多数情况下都有效，对于 1000 它有时会工作并且大部分时间都会失败，对于 10000 它几乎每次都会失败，它如果我告诉它在subscribeOn()上运行它，如果我根本不使用$(function () { $('.datepicker').datepicker({ format: 'd-M-yyyy' }); });，则有效。

如何解决此问题？

Answer 1

如何解决此问题？

不要使用该模式。你为什么要首先这样做？

io和newThread创建操作系统线程，并且基本上受操作系统功能和可用内存的限制。

computation有一组固定的线程，可以处理更多的Flowable，因为它们被分配给一个现有的工作线程。

Answer 2

您遇到的问题不是Observables的某些限制，而是您的代码存在问题。您将blockingSubscribe发送到Flowable，它与Flowable无关，跨越所有其他线程。对于higherBound的小值，您会看到代码有效，而对于较大的值则没有，因为外部Flowable可能与内部Flowable一样快higherBound但是对于higherBound的高值，崩溃得更快。

我想说的是，为了看到正确的结果，您需要与跨越所有其他线程而不是外部线程的Flowable同步。我还会用线程安全的实现long sum替换LongAdder sum，您可以使用flatMap运算符来实现此目的。

Flowable.rangeLong(lowerBound, higherBound + 1)
         .flatMap(t -> Flowable.just(t)
                 .subscribeOn(Schedulers.io())
         )
         .doOnNext(sum::add)
         .doOnComplete(() -> {
             long actualSum = (higherBound * (higherBound + 1)) / 2;
             log("SUM: " + sum.longValue() + ", ACTUAL: " + actualSum);
             log("Equals: " + (actualSum == sum.longValue()));
         })
         .blockingSubscribe();

我们可以在Scheduler上运行的Observable数量是否有限制？

2 个答案: