Rx java 如何展平流动性<；可上市未来<；列表<；T>&燃气轮机&燃气轮机；可流动<；T>；异步？

我正在使用rxjava2.0.0-RC4

在我的应用程序中，我收到一个

Flowable.fromIterable（future.get（））；

---

但这涉及到一个阻塞调用（

Future.get（）

）。理想情况下，我希望以完全非阻塞的方式创建flowable，这样它将在基础期货完成后立即发出项目（我不需要保留结果flowable中元素的顺序）。

您可以尝试以下方法：

@Test
public void name() throws Exception {
    ListenableFuture<List<Integer>> listListenableFuture = Futures.immediateFuture(Arrays.asList(1, 2, 3));

    Flowable<List<Integer>> futures = Flowable.fromCallable(() -> listListenableFuture.get());

    Flowable<Integer> integerFlowable = futures
            .flatMap(integers -> Flowable.fromIterable(integers));

    TestSubscriber<Integer> test = integerFlowable.test();

    test.assertValues(1, 2, 3);
}

    @Test
public void name() throws Exception {
    ListenableFuture<List<Integer>> listListenableFuture = Futures.immediateFuture(Arrays.asList(1, 2, 3));

    Flowable<List<Integer>> listFlowable = Flowable.create(e -> {
        if (e.isCancelled()) {
            return;
        }

        try {
            FutureCallback<List<Integer>> futureCallback = new FutureCallback<List<Integer>>() {
                @Override
                public void onSuccess(List<Integer> result) {
                    if (!e.isCancelled()) {
                        printCurrentThread("inOnSuccess");

                        e.onNext(result);
                        e.onComplete();
                    }
                }

                @Override
                public void onFailure(Throwable t) {
                    if (!e.isCancelled()) {
                        e.onError(t);
                    }
                }
            };

            Futures.addCallback(listListenableFuture, futureCallback);

            e.setDisposable(Disposables.fromFuture(listListenableFuture, true));

        } catch (Exception ex) {
            e.onError(ex);
        }

    }, BackpressureStrategy.BUFFER);

    Flowable<Integer> integerFlowable = listFlowable
            .subscribeOn(Schedulers.computation())
            .observeOn(Schedulers.newThread())
            .doOnNext(integers -> printCurrentThread("afterObserveOn"))
            .flatMap(Flowable::fromIterable);

    TestSubscriber<Integer> test = integerFlowable.test();

    Thread.sleep(200);

    test.assertResult(1, 2, 3);
}

private void printCurrentThread(String additional) {
    System.out.println(additional + "_" + Thread.currentThread());
}

@测试
public void name（）引发异常{
ListenableFuture ListenableFuture=Futures.immediateFuture（Arrays.asList（1,2,3））；
Flowable futures=Flowable.fromCallable（（）->listListenableFuture.get（））；
可流动整数可流动=未来
.flatMap（整数->可流动.fromIterable（整数））；
TestSubscriber test=integerFlowable.test（）；
测试资产价值（1,2,3）；
}

如果引入subscribeOn/observeOn，测试将失败。我建议通过挂接生命周期事件来包装ListenableFuture

包装看起来像这样：

@Test
public void name() throws Exception {
    ListenableFuture<List<Integer>> listListenableFuture = Futures.immediateFuture(Arrays.asList(1, 2, 3));

    Flowable<List<Integer>> futures = Flowable.fromCallable(() -> listListenableFuture.get());

    Flowable<Integer> integerFlowable = futures
            .flatMap(integers -> Flowable.fromIterable(integers));

    TestSubscriber<Integer> test = integerFlowable.test();

    test.assertValues(1, 2, 3);
}

    @Test
public void name() throws Exception {
    ListenableFuture<List<Integer>> listListenableFuture = Futures.immediateFuture(Arrays.asList(1, 2, 3));

    Flowable<List<Integer>> listFlowable = Flowable.create(e -> {
        if (e.isCancelled()) {
            return;
        }

        try {
            FutureCallback<List<Integer>> futureCallback = new FutureCallback<List<Integer>>() {
                @Override
                public void onSuccess(List<Integer> result) {
                    if (!e.isCancelled()) {
                        printCurrentThread("inOnSuccess");

                        e.onNext(result);
                        e.onComplete();
                    }
                }

                @Override
                public void onFailure(Throwable t) {
                    if (!e.isCancelled()) {
                        e.onError(t);
                    }
                }
            };

            Futures.addCallback(listListenableFuture, futureCallback);

            e.setDisposable(Disposables.fromFuture(listListenableFuture, true));

        } catch (Exception ex) {
            e.onError(ex);
        }

    }, BackpressureStrategy.BUFFER);

    Flowable<Integer> integerFlowable = listFlowable
            .subscribeOn(Schedulers.computation())
            .observeOn(Schedulers.newThread())
            .doOnNext(integers -> printCurrentThread("afterObserveOn"))
            .flatMap(Flowable::fromIterable);

    TestSubscriber<Integer> test = integerFlowable.test();

    Thread.sleep(200);

    test.assertResult(1, 2, 3);
}

private void printCurrentThread(String additional) {
    System.out.println(additional + "_" + Thread.currentThread());
}

@测试
public void name（）引发异常{
ListenableFuture ListenableFuture=Futures.immediateFuture（Arrays.asList（1,2,3））；
可流动列表可流动=可流动。创建（e->{
如果（如isCancelled（））{
返回；
}
试一试{
FutureCallback FutureCallback=新的FutureCallback（）{
@凌驾
成功时公开作废（列表结果）{
如果（！e.isCancelled（））{
printCurrentThread（“InUnsuccess”）；
e、 onNext（结果）；
e、 onComplete（）；
}
}
@凌驾
失效时的公共无效（可丢弃的t）{
如果（！e.isCancelled（））{
e、 onError（t）；
}
}
};
Futures.addCallback（listListenableFuture，futureCallback）；
e、 设置一次性（一次性。来自未来（listListenableFuture，true））；
}捕获（例外情况除外）{
e、 onError（ex）；
}
}，背压调节（缓冲）；
可流动整数可流动=列表可流动
.subscribeOn（Schedulers.computation（））
.observeOn（Schedulers.newThread（））
.doOnNext（整数->printCurrentThread（“afterObserveOn”））
.flatMap（可流动：：fromIterable）；
TestSubscriber test=integerFlowable.test（）；
睡眠（200）；
测试结果（1,2,3）；
}
私有void printCurrentThread（字符串附加）{
System.out.println（附加+“”+Thread.currentThread（））；
}

您可以尝试以下方法：

@Test
public void name() throws Exception {
    ListenableFuture<List<Integer>> listListenableFuture = Futures.immediateFuture(Arrays.asList(1, 2, 3));

    Flowable<List<Integer>> futures = Flowable.fromCallable(() -> listListenableFuture.get());

    Flowable<Integer> integerFlowable = futures
            .flatMap(integers -> Flowable.fromIterable(integers));

    TestSubscriber<Integer> test = integerFlowable.test();

    test.assertValues(1, 2, 3);
}

    @Test
public void name() throws Exception {
    ListenableFuture<List<Integer>> listListenableFuture = Futures.immediateFuture(Arrays.asList(1, 2, 3));

    Flowable<List<Integer>> listFlowable = Flowable.create(e -> {
        if (e.isCancelled()) {
            return;
        }

        try {
            FutureCallback<List<Integer>> futureCallback = new FutureCallback<List<Integer>>() {
                @Override
                public void onSuccess(List<Integer> result) {
                    if (!e.isCancelled()) {
                        printCurrentThread("inOnSuccess");

                        e.onNext(result);
                        e.onComplete();
                    }
                }

                @Override
                public void onFailure(Throwable t) {
                    if (!e.isCancelled()) {
                        e.onError(t);
                    }
                }
            };

            Futures.addCallback(listListenableFuture, futureCallback);

            e.setDisposable(Disposables.fromFuture(listListenableFuture, true));

        } catch (Exception ex) {
            e.onError(ex);
        }

    }, BackpressureStrategy.BUFFER);

    Flowable<Integer> integerFlowable = listFlowable
            .subscribeOn(Schedulers.computation())
            .observeOn(Schedulers.newThread())
            .doOnNext(integers -> printCurrentThread("afterObserveOn"))
            .flatMap(Flowable::fromIterable);

    TestSubscriber<Integer> test = integerFlowable.test();

    Thread.sleep(200);

    test.assertResult(1, 2, 3);
}

private void printCurrentThread(String additional) {
    System.out.println(additional + "_" + Thread.currentThread());
}

@测试
public void name（）引发异常{
ListenableFuture ListenableFuture=Futures.immediateFuture（Arrays.asList（1,2,3））；
Flowable futures=Flowable.fromCallable（（）->listListenableFuture.get（））；
可流动整数可流动=未来
.flatMap（整数->可流动.fromIterable（整数））；
TestSubscriber test=integerFlowable.test（）；
测试资产价值（1,2,3）；
}

如果引入subscribeOn/observeOn，测试将失败。我建议通过挂接生命周期事件来包装ListenableFuture

包装看起来像这样：

@Test
public void name() throws Exception {
    ListenableFuture<List<Integer>> listListenableFuture = Futures.immediateFuture(Arrays.asList(1, 2, 3));

    Flowable<List<Integer>> futures = Flowable.fromCallable(() -> listListenableFuture.get());

    Flowable<Integer> integerFlowable = futures
            .flatMap(integers -> Flowable.fromIterable(integers));

    TestSubscriber<Integer> test = integerFlowable.test();

    test.assertValues(1, 2, 3);
}

    @Test
public void name() throws Exception {
    ListenableFuture<List<Integer>> listListenableFuture = Futures.immediateFuture(Arrays.asList(1, 2, 3));

    Flowable<List<Integer>> listFlowable = Flowable.create(e -> {
        if (e.isCancelled()) {
            return;
        }

        try {
            FutureCallback<List<Integer>> futureCallback = new FutureCallback<List<Integer>>() {
                @Override
                public void onSuccess(List<Integer> result) {
                    if (!e.isCancelled()) {
                        printCurrentThread("inOnSuccess");

                        e.onNext(result);
                        e.onComplete();
                    }
                }

                @Override
                public void onFailure(Throwable t) {
                    if (!e.isCancelled()) {
                        e.onError(t);
                    }
                }
            };

            Futures.addCallback(listListenableFuture, futureCallback);

            e.setDisposable(Disposables.fromFuture(listListenableFuture, true));

        } catch (Exception ex) {
            e.onError(ex);
        }

    }, BackpressureStrategy.BUFFER);

    Flowable<Integer> integerFlowable = listFlowable
            .subscribeOn(Schedulers.computation())
            .observeOn(Schedulers.newThread())
            .doOnNext(integers -> printCurrentThread("afterObserveOn"))
            .flatMap(Flowable::fromIterable);

    TestSubscriber<Integer> test = integerFlowable.test();

    Thread.sleep(200);

    test.assertResult(1, 2, 3);
}

private void printCurrentThread(String additional) {
    System.out.println(additional + "_" + Thread.currentThread());
}

@测试
public void name（）引发异常{
ListenableFuture ListenableFuture=Futures.immediateFuture（Arrays.asList（1,2,3））；
可流动列表可流动=可流动。创建（e->{
如果（如isCancelled（））{
返回；
}
试一试{
FutureCallback FutureCallback=新的FutureCallback（）{
@凌驾
成功时公开作废（列表结果）{
如果（！e.isCancelled（））{
printCurrentThread（“InUnsuccess”）；
e、 onNext（结果）；
e、 onComplete（）；
}
}
@凌驾
失效时的公共无效（可丢弃的t）{
如果（！e.isCancelled（））{
e、 onError（t）；
}
}
};
Futures.addCallback（listListenableFuture，futureCallback）；
e、 设置一次性（一次性。来自未来（listListenableFuture，true））；
}捕获（例外情况除外）{
e、 onError（ex）；
}
}，背压调节（缓冲）；
可流动整数可流动=列表可流动
.subscribeOn（Schedulers.computation（））
.observeOn（Schedulers.newThread（））
.doOnNext（整数->printCurrentThread（“afterObserveOn”））
.flatMap（可流动：：fromIterable）；
TestSubscriber test=integerFlowable.test（）；
睡眠（200）；
测试结果（1,2,3）；
}
私有void printCurrentThread（字符串附加）{
System.out.println（附加+“”+Thread.currentThread（））；
}

您的第二个解决方案很有效，正是我想要的那种回调方式，非常感谢！为了记录在案，我不得不用FlowableEmitter.BackpressureMode.BUFFER替换BackPressureStragy.BUFFER。我添加了更多的isCancelled测试。您的第二个解决方案很有效，正是我所寻找的回调样式，非常感谢！为了记录在案，我不得不用FlowableEmitter.BackpressureMode.BUFFER替换BackPressureStragy.BUFFER。我添加了更多的isCancelled测试。