RX之异步操作（start、toAsync、startFuture、deferFuture、fromAction、fromRunnable、forEachFuture、runAsync）

最新推荐文章于 2024-07-29 02:25:37 发布
最新推荐文章于 2024-07-29 02:25:37 发布
阅读量3.4k 收藏 1
点赞数 1
分类专栏： RX
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nicolelili1/article/details/52181469
版权

需要在buld.gradle中加入compile 'io.reactivex:rxjava-async-util:0.21.0'

一、start

返回一个Observable，它发射一个类似于函数声明的值。编程语言有很多种方法可以从运算结果中获取值，它们的名字一般叫functions, futures, actions, callables, runnables等等。在Start目录下的这组操作符可以让它们表现得像Observable，因此它们可以在Observables调用链中与其它Observable搭配使用。Start操作符的多种RxJava实现都属于可选的rxjava-async模块。

rxjava-async模块包含start操作符，它接受一个函数作为参数，调用这个函数获取一个值，然后返回一个会发射这个值给后续观察者的Observable。

注意：这个函数只会被执行一次，即使多个观察者订阅这个返回的Observable。

 Observable<Integer> observable = Async.start(new Func0<Integer>() {
            @Override
            public Integer call() {
                //函数内为异步操作
                try {
                    Thread.sleep(5 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return 20;
            }
        });

        Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            @Override
            public void onNext(Integer v) {
                Log.e(TAG, "onNext................." + v);

            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        observable.subscribe(subscriber);
5s后才输出打印结果
运行结果：


二、toAsync

rxjava-async模块还包含这几个操作符：toAsync, asyncAction, 和asyncFunc。它们接受一个函数或一个Action作为参数。对于函数(functions)，这个操作符调用这个函数获取一个值，然后返回一个会发射这个值给后续观察者的Observable（和start一样）。对于动作(Action)，过程类似，但是没有返回值，在这种情况下，这个操作符在终止前会发射一个null值。

注：这个函数或动作只会被执行一次，即使多个观察者订阅这个返回的Observable。

 Func0<Observable<Integer>> func0 = Async.toAsync(new Func0<Integer>() {
            @Override
            public Integer call() {
                //函数内为异步操作
                try {
                    Thread.sleep(5 * 1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return 20;
            }
        });
        Observable<Integer> observable = func0.call();

        Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            @Override
            public void onNext(Integer v) {
                Log.e(TAG, "onNext................." + v);

            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };
        observable.subscribe(subscriber);

运行结果：


三、startFuture

xjava-async模块还包含一个startFuture操作符，传递给它一个返回Future的函数，startFuture会立即调用这个函数获取Future对象，然后调用Future的get()方法尝试获取它的值。它返回一个发射这个值给后续观察者的Observable。

final Future<Integer> future = Executors.newCachedThreadPool().submit(new Task());
        Observable<Integer> observable = Async.startFuture(new Func0<Future<Integer>>() {
            @Override
            public Future<Integer> call() {
                //函数内为异步操作
                return future;
            }
        });


        Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            @Override
            public void onNext(Integer v) {
                Log.e(TAG, "onNext................." + v);

            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        observable.subscribe(subscriber);

运行结果：

10s后才输出打印结果


四、deferFuture

deferFuture中的函数可以异步执行一些操作，当完成后返回一个Observable，但是这个Observable不会立刻发射数据，直到开始订阅时。 

rxjava-async模块还包含一个deferFuture操作符，传递给它一个返回Future的函数（这个Future返回一个Observable），deferFuture返回一个Observable，但是不会调用你提供的函数，知道有观察者订阅它返回的Observable。这时，它立即调用Future的get()方法，然后镜像发射get()方法返回的Observable发射的数据。

用这种方法，你可以在Observables调用链中包含一个返回Observable的Future对象。

 Observable<Long> observable = Observable.interval(1,TimeUnit.SECONDS).take(5);

        final Future<Observable<Integer>> future = Executors.newCachedThreadPool().submit(new ObservableTask());
        final Observable<Integer> observable1 = Async.deferFuture(new Func0<Future<Observable<Integer>>>() {
            @Override
            public Future<Observable<Integer>> call() {
                return future;
            }
        });

        final Subscriber<Integer> subscriber1 = new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "onNext1................." + integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted1.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError1.....................");
            }
        };

        Subscriber<Long> subscriber = new Subscriber<Long>() {
            @Override
            public void onNext(Long integer) {
                Log.e(TAG, "onNext................." + integer);
                if(integer == 4){
                    observable1.subscribe(subscriber1);
                }
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };


        observable.subscribe(subscriber);

运行结果：



五、fromAction

当fromAction()中的函数Action0执行完成后发射数据。Action无返回结果。rxjava-async模块还包含一个fromAction操作符，它接受一个Action作为参数，返回一个Observable，一旦Action终止，它发射这个你传递给fromAction的数据。

        final int result = 1;
        final Observable<Integer> observable = Async.fromAction(new Action0() {
            @Override
            public void call() {

                for(int i=1;i<10;i++){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        },result);

        final Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "onNext1................." + integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted1.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError1.....................");
            }
        };

        observable.subscribe(subscriber);


运行结果：


六、fromCallable

当fromCallable中的函数运行完成后将其结果发射出去。rxjava-async模块还包含一个fromCallable操作符，它接受一个Callable作为参数，返回一个发射这个Callable的结果的Observable。

 final Observable<Integer> observable = Async.fromCallable(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int result = 1;
                for(int i=1;i<10;i++){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    result *= i;
                }
                return result;
            }
        });

        final Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "onNext1................." + integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted1.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError1.....................");
            }
        };

        observable.subscribe(subscriber);
运行结果：


七、fromRunnable

当run方法执行完成后发送传入的参数数据。rxjava-async模块还包含一个fromRunnable操作符，它接受一个Runnable作为参数，返回一个Observable，一旦Runnable终止，它发射这个你传递给fromRunnable的数据。

        //当runnable执行完成后所需发射的数据
        int result = 20;
         Observable<Integer> observable = Async.fromRunnable(new Runnable() {
             @Override
             public void run() {
                 for(int i=1;i<10;i++){
                     try {
                         Thread.sleep(1000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                 }
             }
         },result);

         Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "onNext1................." + integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted1.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError1.....................");
            }
        };

        observable.subscribe(subscriber);
运行结果：


八、forEachFuture

rxjava-async模块还包含一个forEachFuture操作符。它其实不算Start操作符的一个变体，而是有一些自己的特点。你传递一些典型的观察者方法（如onNext, onError和onCompleted）给它，Observable会以通常的方式调用它。但是forEachFuture自己返回一个Future并且在get()方法处阻塞，直到原始Observable执行完成，然后它返回，完成还是错误依赖于原始Observable是完成还是错误。

如果你想要一个函数阻塞直到Observable执行完成，可以使用这个操作符。


private void testForEachFuture() {

        Async.forEachFuture(Observable.just(1, 2, 3, 4, 5),
                new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        newInfo(integer);

                    }
                });

    }


    private void newInfo(Integer integer){
        Log.e(TAG, "newInfo.................收到的数据是：" + integer+"..............转换成："+integer*20);
    }


运行结果：



九、runAsync

任何时候都可以通过subscription的unsubscrip来停止订阅。rxjava-async模块还包含一个runAsync操作符。它很特殊，返回一个叫做StoppableObservable的特殊Observable。传递一个Action和一个Scheduler给runAsync，它返回一个使用这个Action产生数据的StoppableObservable。这个Action接受一个Observable和一个Subscription作为参数，它使用Subscription检查unsubscribed条件，一旦发现条件为真就立即停止发射数据。在任何时候你都可以使用unsubscribe方法手动停止一个StoppableObservable（这会同时取消订阅与这个StoppableObservable关联的Subscription）。

由于runAsync会立即调用Action并开始发射数据，在你创建StoppableObservable之后到你的观察者准备好接受数据之前这段时间里，可能会有一部分数据会丢失。如果这不符合你的要求，可以使用runAsync的一个变体，它也接受一个Subject参数，传递一个ReplaySubject给它，你可以获取其它丢失的数据了。在RxJava中还有一个版本的From操作符可以将Future转换为Observable，与start相似。

 //action所需要执行的线程
        Scheduler scheduler = Schedulers.newThread();
        Action2<? super Observer<? super Integer>, ? super Subscription> action = new Action2<Observer<? super Integer>, Subscription>() {
            @Override
            public void call(Observer<? super Integer> observer, Subscription subscription) {
               int i = 1;
                while (!subscription.isUnsubscribed()){
                    Log.e(TAG, "call................observer.onNext");
                    observer.onNext(i);
                    i += 1;
                    if(i == 4){
                        subscription.unsubscribe();
                        observer.onCompleted();
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        };

       StoppableObservable<Integer> stoppableObservable  =  Async.runAsync(scheduler, action);

        Subscriber<Integer> subscriber = new Subscriber<Integer>() {
            @Override
            public void onNext(Integer integer) {
                Log.e(TAG, "onNext................." + integer);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        stoppableObservable.subscribe(subscriber);

运行结果：


nicolelili1
关注
专栏目录
获取双异步返回值时，如何保证主线程不阻塞？
学Java，找哪吒
01-25 1401
CompletableFuture的异步执行通过ForkJoinPool实现，ForkJoinPool在于可以充分利用多核CPU的优势，把一个任务拆分成多个小任务，把多个小任务放到多个CPU上并行执行，当多个小任务执行完毕后，再将其执行结果合并起来。
MySQL:使用Java创建同步和异步MySQL连接和操作！
05-19
异步操作则允许Java应用在等待数据库响应时执行其他任务，提高程序效率。Java 8引入了CompletableFuture，可以用来实现异步数据库操作。以下是一个使用CompletableFuture的例子： ```java import java.sql....
RxJava线程调度
测试
07-20 267
介绍 RxJava中除了操作符外,线程调度也是其一大特点,也可以说是RxJava中最重要的一部份了. Rxjava线程调度的使用很简单 subscribeOn()指定订阅的线程,也就是事件处理的线程 observeOn()指定观察的线程,就是事件处理结果返回的线程 调度器类型 效果 Schedulers.computation( ) 用于计算任务，如...
Future结合RxJava 实现异步调用
huangshanchun的专栏
06-03 3473
0 概述在实际工作中，时常会遇到一个接口服务会调用很多其他的服务（10几个甚至更多，这些服务之间大多都不是相互依赖的）,如果采用串行化调用，那么这个接口的服务rt（response time）就会很高，20*50ms=1000ms（假设该接口服务需要调用20个服务，平均每个服务rt为50ms）。本文主要给出Future结合Rxjava 实现异步化调用。1 异步化调用用户信息的异步查询，需要你调用服务
Mono.fromRunnable 和 Mono.zip 的详细解释和示例
最新发布
weixin_32307021的博客
07-29 76
Mono.fromRunnable Mono.fromRunnable 是一种创建 Mono 的方式，它接受一个 Runnable 作为参数。当 Mono 订阅者订阅时，Runnable 会被执行。Mono.fromRunnable 不会发出任何值，只会执行 Runnable 的逻辑，并在完成后发出一个完成信号。示例登录后...
电子书包 android,RxJava学习指南(四)——创建操作符
weixin_28760959的博客
05-26 170
RxJava学习指南(四)——创建操作符RxJava学习指南版本：5整理：陈小默五、创建操作符5.1 Create使用一个函数从头开始创建一个Observable你可以使用Create操作符从头开始创建一个Observable。其中的onComplete或onError只能被执行一个并且只能被执行一次。RxJava将这个操作符实现为 create 方法。建议你在传递给create方法的函数中检查观...
RxJava2.x 创建操作符之 from
「程序员飞飞」的博客
05-19 1884
题图：Pixabay License 哈喽，朋友们，上一篇文章我们学习了 create & just 操作符，今天我们继续来学习 from 操作符。 from 操作符和 just 操作符一样，也属于创建操作符的一种，from 可将其他种类的对象和数据类型转换为 Observable。 从概念看，just 和 from 是比较相似的，那么，他们两者有什么区别呢？ just 只是简单的原样发...
spring boot中使用@Async实现异步调用任务
08-31
在Spring Boot中，异步调用是通过Spring的`@Async`注解来实现的，它允许我们在不阻塞主线程的情况下执行耗时的操作。这极大地提高了应用的响应速度，尤其是在处理大量并发请求时。接下来，我们将深入探讨如何在...
JavaScript异步操作的几种常见处理方法实例总结
10-15
JavaScript异步操作是编程中一个至关重要的概念，尤其是在前端开发中。异步处理允许程序在等待某些耗时操作（如网络请求或定时器）完成时，继续执行其他任务，提高程序的响应速度和效率。本篇文章将总结JavaScript...
Java并发 CompletableFuture异步编程的实现
08-25
在 Java 中，CompletableFuture 是一种异步编程的实现方式，它可以帮助开发者轻松地实现异步操作。CompletableFuture 的核心优势在于它可以将串行操作变成并行操作，从而提高性能。 异步化是并行方案得以实施的基础...
响应式编程简介
weixin_45577053的博客
01-29 4411
对于响应式编程的解释 个人理解： Java中传统的线程接口有两种，一种是Runable,一种是Callable；一个没有返回值，一个有返回值；Callable的返回值用Future来接收。无论是Runable还是Callable，都要等线程执行完才能继续操作下去，这个过程中就造成了阻塞。 如果想我把任务分配下去，并且告诉他任务执行完成就怎么怎么样，然后我就不用管了，这样一种思想可以理解成是响应式编程，就像是“好莱坞原则”（演员不用主动联系导演，导演会去联系演员，也就是你不要来找我，我会去找你）。 响
CompletableFuture详解~runAsync
小强快跑~~
02-27 3万+
这个例子创建一个一个异步执行的阶段： static void runAsyncExample() { CompletableFuture cf = CompletableFuture.runAsync(() -> { assertTrue(Thread.currentThread().isDaemon()); randomSleep(); }); assertFalse(cf.isDone()); sleepEnough();
Mono入门应用
热门推荐
海锋博客
02-03 6万+
前言 Flux 和 Mono 是 Reactor 中的两个基本概念。Flux 表示的是包含 0 到 N 个元素的异步序列。在该序列中可以包含三种不同类型的消息通知：正常的包含元素的消息、序列结束的消息和序列出错的消息。当消息通知产生时，订阅者中对应的方法onNext(), onComplete()和 onError()会被调用。Mono 表示的是包含 0 或者 1 个元素的异步序列。该序列中
Concurrent 包结构介绍
学习印记 Learning imprint
11-21 1985
java 中Concurrent 包下面提供了java的并发编程的一些基本工具，能够使我们更高效写出线程安全的代码，也减少了自己使用不当导致线程死锁的可能。 Concurrent 包主要包括 atomic基本类型类，基于AQS各种锁的实现，线程池框架，线程安全的集合类，线程并发控制类（CountDownLatch，CyclicBarrier），future接口实现。 结构 Concurrent 包下面包含了 atomic 包和 locks 包，还有Concurrent 下面直接的类。 atomic 包 at
异步调用（多线程）
weixin_46237429的博客
05-22 2885
异步调用FutureCompletableFuture异步开启案例：方法说明runAsyncsupplyAsyncthenRunthenApplythenAcceptthenComposethenCombine（and聚合）thenAcceptBoth（and聚合）runAfterBoth（and聚合）applyToEither（or聚合）exceptionally(异常处理)whenComplete(异常处理)handle(异常处理)所有代码 Future 一般不使用Future Future 也是一个异
并发工具类(四)
二狗家有矿
02-19 663
1.写在前面 前面的几篇博客介绍了并发工具类的其中的一部分，今天是最后并发工具类是最后一篇博客，后面的博客会介绍并发的模式。好了，废话不多说，直接上内容吧。 2.CompletableFuture:异步编程 异步化的编程，利用多线程优化性能这个核心方案得以实施的基础。 2.1CompletableFuture 的核心优势 我们再来看下上篇博客中讲的烧茶泡水的例子，具体的分工图如下： 实现的代码如下： // 任务 1：洗水壶 -> 烧开水 CompletableFuture<V
RxJava的初步使用
yuemingxingxing的博客
07-04 127
1.普通订阅 Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() { @Override public void subscribe(ObservableEmitter<String> em...
CompletableFuture.runAsync异步失效
06-18
`CompletableFuture.runAsync` 是 Java 中用于异步执行任务的方法，通常用于提高代码的并发性能和响应性。当你通过 `runAsync` 方法在一个 `CompletableFuture` 对象上执行一个任务时，这个任务会在一个新的线程中开始执行，并返回一个表示该任务完成状态的 `CompletableFuture`。 然而，`runAsync` 并不会自动保证异步操作的执行，如果在调用 `runAsync` 后，主线程很快地阻塞或者结束，那么原本预期在其他线程中运行的任务实际上可能会变成同步执行，因为没有其他的线程可以接替处理。这被称为“隐式同步”或“异步失效”。 导致这种情况的原因可能有： 1. 主线程在调用 `runAsync` 后立即等待某个结果，比如使用 `thenApply`、`thenAccept` 或其他阻塞操作。 2. 在调用 `runAsync` 后，没有正确设置回调或 Future 的完成监听，导致无法感知异步任务的结果。 3. `CompletableFuture` 的链式调用中，后续的操作没有正确地利用并发性质，使得整个链路变成了同步执行。 为了避免异步失效，你应该确保： - 不在 `runAsync` 后立即阻塞，而是使用非阻塞的方式处理结果（如 `.thenApply` 后跟一个无阻塞的回调）。 - 设置 Future 的完成监听器，以便在任务完成后得到通知。 - 尽量利用 `CompletableFuture` 提供的并发工具，例如 `.thenCompose` 和 `.join()` 的区别，确保在正确的地方处理并行性。 如果你需要确保任务确实异步执行，请考虑使用 `.submit` 方法，这样任务将被提交到线程池，而不是直接在当前线程执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值