Question

我一直在我们的代码库中尝试rxJava，主要是希望增加并发性提升性能。但是，当我使用rxJava时，似乎存在开销/启动成本问题。在下面的示例中，在“doRx（）”中，在触发getAllElements（）之前需要约130ms，而在“doOld”中，在触发getAllElements（）之前需要0ms。我最初在doRx（）中失去130ms的原因有什么解释？

这是我使用System.currentTimeMillis（）进行的日志记录。（）是从init（）开始经过的时间。

现有实施

（0）2016-10-11T13：34：07.060：OldImpl：init（）
（0）2016-10-11T13：34：07.060：OldImpl：调用getAllElements（）
（327）2016-10-11T13：34：07.387：OldImpl：收到getAllElements（）

RX实施

（0）2016-10-11T13：34：07.703：RxImpl：init（）
（ 160 ）2016-10-11T13：34：07.863：RxImpl：致电 getAllElements（）
（392）2016-10-11T13：34：08.095：RxImpl：收到了getAllElements（）

代码背后的原因是我首先要收集所有元素，然后并行运行它们（在h2下），因为这是我们可以节省时间的地方，因为有很多后端调用。我已使用this blog作为此设置的指导。

public List<Element> doRx() {

    List<Element> elements = new ArrayList<>();

    Observable
            .from(getAllElements())
            .flatMap(
                    s -> Observable
                            .just(Element::new)
                            .subscribeOn(Schedulers.io())
                            .flatMap(
                                    e -> {

                                        List<Element> elements = new ArrayList<>();

                                        for (SubElement se : e.getSubElements()) {

                                            elements.add(se);

                                        }

                                        return Observable.from(elements);
                                    }
                            )
            )
            .flatMap(

                    h1 -> Observable
                            .just(h1)
                            .subscribeOn(Schedulers.computation())
                            .flatMap(
                                    h2 -> {

                                        // Do additional things in parallell on all elements

                                        return Observable
                                                .just(h2);
                                    }
                            )
            )
            .toBlocking()
            .getIterator()
            .forEachRemaining(myList::add);

    return elements;
}


public List<Element> doOld() {

    List<Element> elements = getAllElements();

    for (Element e : elements) {
        // Do stuff, same as under h2   
    }

    return elements;
}

Answer 1

如果我理解你的代码正确，它等同于以下内容：

public List<Element> doRx() {
    return Observable
        .from(getAllElements())
        .flatMap(element -> Observable
             .just(new Element(element))
             .subscribeOn(Schedulers.io())
             .flatMaplIterable(e -> e.getSubElements())
        )
        .observeOn(Schedulers.computation())
        .doOnNext(element -> {
            // Do additional things in parallell on all elements
        })
        .toList()
        .toBlocking()
        .single();
}

每个元素至少有2个上下文切换比顺序版本更多。你是如何做你的时间的？ X运行，忽略最大和最小的数字？

在rxJava中的开销

1 个答案: