RxJava和RxAndroid

最新推荐文章于 2021-04-14 20:58:46 发布
最新推荐文章于 2021-04-14 20:58:46 发布
阅读量330 收藏
点赞数
分类专栏： 基础知识 文章标签： rxjava

线程调度

本节将有几个例子说明rxjava线程调度的正确使用姿势。

例1

    Observable.create(new Observable.OnSubscribe<String>() {
                   @Override
                   public void call(Subscriber<? super String> subscriber) {
                       Logger.v( "rx_call" , Thread.currentThread().getName()  );

                       subscriber.onNext( "dd");
                       subscriber.onCompleted();
                   }
               })
               .map(new Func1<String, String >() {
                   @Override
                   public String call(String s) {
                       Logger.v( "rx_map" , Thread.currentThread().getName()  );
                       return s + "88";
                   }
               })
               .subscribe(new Action1<String>() {
                   @Override
                   public void call(String s) {
                       Logger.v( "rx_subscribe" , Thread.currentThread().getName()  );
                   }
               }) ;

结果

/rx_call: main           -- 主线程
/rx_map: main        --  主线程
/rx_subscribe: main   -- 主线程

例2

new Thread(new Runnable() {
           @Override
           public void run() {
               Logger.v( "rx_newThread" , Thread.currentThread().getName()  );
               rx();
           }
       }).start();

void rx(){
            Observable.create(new Observable.OnSubscribe<String>() {
                   @Override
                   public void call(Subscriber<? super String> subscriber) {
                       Logger.v( "rx_call" , Thread.currentThread().getName()  );

                       subscriber.onNext( "dd");
                       subscriber.onCompleted();
                   }
               }).map(new Func1<String, String >() {
                   @Override
                   public String call(String s) {
                       Logger.v( "rx_map" , Thread.currentThread().getName()  );
                       return s + "88";
                   }
               }).subscribe(new Action1<String>() {
                   @Override
                   public void call(String s) {
                       Logger.v( "rx_subscribe" , Thread.currentThread().getName()  );
                   }
               }) ;
   }

结果

/rx_newThread: Thread-564   -- 子线程
/rx_call: Thread-564              -- 子线程
/rx_map: Thread-564            -- 子线程 
/rx_subscribe: Thread-564    -- 子线程

通过例1和例2，说明，Rxjava默认运行在当前线程中。如果当前线程是子线程，则rxjava运行在子线程；同样，当前线程是主线程，则rxjava运行在主线程

例3

Observable
               .create(new Observable.OnSubscribe<String>() {
                   @Override
                   public void call(Subscriber<? super String> subscriber) {
                       Logger.v( "rx_call" , Thread.currentThread().getName()  );

                       subscriber.onNext( "dd");
                       subscriber.onCompleted();
                   }
               })

               .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())

               .map(new Func1<String, String >() {
                   @Override
                   public String call(String s) {
                       Logger.v( "rx_map" , Thread.currentThread().getName()  );
                       return s + "88";
                   }
               })
               .subscribe(new Action1<String>() {
                   @Override
                   public void call(String s) {
                       Logger.v( "rx_subscribe" , Thread.currentThread().getName()  );
                   }
               }) ;

结果

/rx_call: RxCachedThreadScheduler-1    --io线程
/rx_map: main                          --主线程
/rx_subscribe: main                    --主线程

例4

Observable
               .create(new Observable.OnSubscribe<String>() {
                   @Override
                   public void call(Subscriber<? super String> subscriber) {
                       Logger.v( "rx_call" , Thread.currentThread().getName()  );

                       subscriber.onNext( "dd");
                       subscriber.onCompleted();
                   }
               })
               .map(new Func1<String, String >() {
                   @Override
                   public String call(String s) {
                       Logger.v( "rx_map" , Thread.currentThread().getName()  );
                       return s + "88";
                   }
               })

               .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())

               .subscribe(new Action1<String>() {
                   @Override
                   public void call(String s) {
                       Logger.v( "rx_subscribe" , Thread.currentThread().getName()  );
                   }
               }) ;

结果

/rx_call: RxCachedThreadScheduler-1     --io线程
/rx_map: RxCachedThreadScheduler-1      --io线程
/rx_subscribe: main                     --主线程

通过例3、例4 可以看出 .subscribeOn(Schedulers.io()) 和 .observeOn(AndroidSchedulers.mainThread()) 写的位置不一样，造成的结果也不一样。从例4中可以看出 map() 操作符默认运行在事件产生的线程之中。事件消费只是在 subscribe（） 里面。

对于 create(),just(),from()等             -- 事件产生
map(),flapMap(),scan(),filter()等        -- 事件加工
subscribe()                              -- 事件消费

事件产生：默认运行在当前线程，可以由 subscribeOn()  自定义线程
事件加工：默认跟事件产生的线程保持一致, 可以由 observeOn() 自定义线程
事件消费：默认运行在当前线程，可以有observeOn() 自定义

例5 多次切换线程

Observable
                .create(new Observable.OnSubscribe<String>() {
                    @Override
                    public void call(Subscriber<? super String> subscriber) {
                        Logger.v( "rx_call" , Thread.currentThread().getName()  );

                        subscriber.onNext( "dd");
                        subscriber.onCompleted();
                    }
                })

                .observeOn( Schedulers.newThread() )    //新线程

                .map(new Func1<String, String >() {
                    @Override
                    public String call(String s) {
                        Logger.v( "rx_map" , Thread.currentThread().getName()  );
                        return s + "88";
                    }
                })

                .observeOn( Schedulers.io() )      //io线程

                .filter(new Func1<String, Boolean>() {
                    @Override
                    public Boolean call(String s) {
                        Logger.v( "rx_filter" , Thread.currentThread().getName()  );
                        return s != null ;
                    }
                })

                .subscribeOn(Schedulers.io())     //定义事件产生线程：io线程
                .observeOn(AndroidSchedulers.mainThread())     //事件消费线程：主线程

                .subscribe(new Action1<String>() {
                    @Override
                    public void call(String s) {
                        Logger.v( "rx_subscribe" , Thread.currentThread().getName()  );
                    }
                }) ;

结果

/rx_call: RxCachedThreadScheduler-1         -- io 线程
/rx_map: RxNewThreadScheduler-1             -- new出来的线程
/rx_filter: RxCachedThreadScheduler-2       -- io线程
/rx_subscribe: main                         -- 主线程

例6 只规定了事件产生的线程

Observable
         .create(new Observable.OnSubscribe<String>() {
             @Override
             public void call(Subscriber<? super String> subscriber) {
                 Log.v( "rx--create " , Thread.currentThread().getName() ) ;
                 subscriber.onNext( "dd" ) ;
             }
         })
         .subscribeOn(Schedulers.io())
         .subscribe(new Action1<String>() {
             @Override
             public void call(String s) {
                 Log.v( "rx--subscribe " , Thread.currentThread().getName() ) ;
             }
         }) ;

结果

/rx--create: RxCachedThreadScheduler-4                    // io 线程
/rx--subscribe: RxCachedThreadScheduler-4                 // io 线程

例7 只规定事件消费线程

Observable
               .create(new Observable.OnSubscribe<String>() {
                   @Override
                   public void call(Subscriber<? super String> subscriber) {
                       Log.v( "rx--create " , Thread.currentThread().getName() ) ;
                       subscriber.onNext( "dd" ) ;
                   }
               })
               .observeOn( Schedulers.newThread() )
               .subscribe(new Action1<String>() {
                   @Override
                   public void call(String s) {
                       Log.v( "rx--subscribe " , Thread.currentThread().getName() ) ;
                   }
               }) ;

结果

/rx--create: main                             -- 主线程
/rx--subscribe: RxNewThreadScheduler-1        --  new 出来的子线程

从例6可以看出，如果只规定了事件产生的线程，那么事件消费线程将跟随事件产生线程。
从例7可以看出，如果只规定了事件消费的线程，那么事件产生的线程和 当前线程保持一致。

例8 线程调度封装
在Android 常常有这样的场景，后台处理处理数据，前台展示数据。
一般的用法：

Observable
             .just( "123" )
             .subscribeOn( Schedulers.io())
             .observeOn( AndroidSchedulers.mainThread() )
             .subscribe(new Action1() {
                 @Override
                 public void call(Object o) {
                 }
             }) ;

但是项目中这种场景有很多，所以我们就想能不能把这种场景的调度方式封装起来，方便调用。

简单的封装

public Observable apply( Observable observable ){
   return observable.subscribeOn( Schedulers.io() )
            .observeOn( AndroidSchedulers.mainThread() ) ;
}

使用

apply( Observable.just( "123" ) )
              .subscribe(new Action1() {
                  @Override
                  public void call(Object o) {

                  }
              }) ;

弊端：虽然上面的这种封装可以做到线程调度的目的，但是它破坏了链式编程的结构，是编程风格变得不优雅。

改进：Transformers 的使用（就是转化器的意思，把一种类型的Observable转换成另一种类型的Observable ）

改进后的封装

Observable.Transformer schedulersTransformer = new  Observable.Transformer() {
    @Override public Object call(Object observable) {
        return ((Observable)  observable).subscribeOn(Schedulers.newThread())
                .observeOn(AndroidSchedulers.mainThread());
    }
};

使用

Observable
          .just( "123" )
          .compose( schedulersTransformer )
          .subscribe(new Action1() {
              @Override
              public void call(Object o) {
              }
          }) ;

弊端：虽然保持了链式编程结构的完整，但是每次调用 .compose( schedulersTransformer ) 都是 new 了一个对象的。所以我们需要再次封装，尽量保证单例的模式。

改进后的封装

package lib.app.com.myapplication;

import rx.Observable;
import rx.android.schedulers.AndroidSchedulers;
import rx.schedulers.Schedulers;

/**
 * Created by ${zyj} on 2016/7/1.
 */
public class RxUtil {

    private final static Observable.Transformer schedulersTransformer = new  Observable.Transformer() {
        @Override public Object call(Object observable) {
            return ((Observable)  observable).subscribeOn(Schedulers.newThread())
                    .observeOn(AndroidSchedulers.mainThread());
        }
    };

   public static  <T> Observable.Transformer<T, T> applySchedulers() {
        return (Observable.Transformer<T, T>) schedulersTransformer;
    }

}

使用

Observable
            .just( "123" )
            .compose( RxUtil.<String>applySchedulers() )
            .subscribe(new Action1() {
                @Override
                public void call(Object o) {
                }
            }) ;

参考链接：
RxJava 和 RxAndroid 五（线程调度）

Zsago
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RxJava2.0.1和RxAndroid2.0.1
03-12
文件内包含RxJava和RxAndroid两个架包，版本是2.0.1。
RxJava 和 RxAndroid 三（生命周期控制和内存优化）
weixin_34253126的博客
05-24 166
rxjava rxandroid 赵彦军 前言：对Rxjava、Rxandroid不了解的同学可以先看看 RxJava 和 RxAndroid RxJava 和 RxAndroid 二（操作符的使用) RxJava使我们很方便的使用链式编程，代码看起来既简洁又优雅。但是RxJava使用起来也是有副作用的，使用越来越多的订阅，内存开销也会变得很大，稍不留神就会出现内存溢出...
RxJava 和 RxAndroid 一 (基础)
fbird45的专栏
10-12 646
RxJava 和 RxAndroid 一 (基础) 1、RxJava 项目地址    https://github.com/ReactiveX/RxJava   2、RxAndroid 项目地址    https://github.com/ReactiveX/RxAndroid   3、RxJava 和 RxAndroid 的关系  
RxJava 和 RxAndroid
CAir2的专栏
08-31 213
RxJava 和 RxAndroid 一 (基础)
重拾Android之路(五)RxJava和RxAndroid
牛谱乐的博客
06-30 1771
现在RxJava和RxAndroid越来越火爆，自己在业余时间也学习了一下，感觉确实很好用，之前 为了完成页面刷新，数据请求，组件信息传递的时候，要使用handler，真的是逻辑思路很强，稍微不注意，就各种错误一大堆。这下有了RxJava和RxAndroid，真的爽。 RxJava 网上有很多给RxJava做定义的，很多人说的比较官方，而我是比较笨的那种人，所以看了很久也没有看懂，不过...
rx-android-playground:使用RxJava和RxAndroid的示例Android应用
05-03
使用RxJava和RxAndroid的示例Android应用 该项目是RxJava + RxAndroid用法的示例。 在我看来，尽管RxJava是一个很棒的工具和概念，但它在Android中的用法远非显而易见。 当重新查询更改后的数据时，ContentProvider...
Simple-Event-Bus:基于RxJava和RxAndroid的简单事件总线
05-11
基于RxJava和RxAndroid的Android简单事件总线 简单事件总线是基于RxAndroid的Android库，可轻松创建和使用事件总线。 它允许您使用不同的参数创建不同的方法，并轻松广播事件并接收它们。 使用此库，您无需包括切换...
RxJava和RxAndroid jar包下载
07-30
里面包含了RxJava 和 RxAndroid 的jar包，方便对RxJava 有兴趣的同学使用，另外附一个RxJava 教程一个http://gank.io/post/560e15be2dca930e00da1083#toc_1
RxJava和RxAndroid学习例子大全
09-06
"RxJava和RxAndroid学习例子大全"包含了各种示例，可以帮助开发者深入理解RxJava和RxAndroid的使用。`appcompat_v7_2`可能包含支持库，用于兼容不同版本的Android设备；`Android_RxJava`则可能是一系列示例代码，...
RxJava RxAndroid jar
10-30
RxJava RxAndroid jar RxJava RxAndroid jar RxJava RxAndroid jar RxJava RxAndroid jar
Rxjava和RxAndroid系列（一）
Justlove_DK的专栏
08-20 2663
一：什么是RxJava:       RxJava是由Netflix开发的响应式扩展（Reactive Extensions）的Java实现。引用MSDN上对它的定义，Reactive Extensions是这样一个第三方库：它结合了可观察集合和LINQ式查询以达到异步和基于事件的编程效果。Netflix将这个库托管到了Github上，支持Java6以上的版本并且使它可以用于Androi
RxJava和RxAndroid用法详解
wl1769127285的专栏
04-27 468
RxJava 在 GitHub 主页上的自我介绍是 "a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。最简单的使用：Observable.create(new...
RxJava/RxAndroid 详解——从基础到实现原理
Kern_的专栏
04-14 1315
[RxJava的github地址：https://github.com/ReactiveX/RxJava](https://github.com/ReactiveX/RxJava) [RxAndroid的github地址：https://github.com/ReactiveX/RxAndroid](https://github.com/ReactiveX/RxAndroid)
RxJava 与 RxAndroid 入门篇
doris_d的专栏
09-27 2777
响应式编程 是一种基于异步数据流概念的编程模式； 事件； RxJava 异步数据处理库 扩展的观察者模式 onCompleted，onError 轻量级框架 支持Java 8 lambda 支持Java 6+ & Android 2.3+ 支持异步和同步 提高工作效率 优雅的解决复杂业务场景 RxAndroid RxJava针对Android平台的扩展，用于Android开发 提供响应式扩展组件，快速、易于开发Android程序 Schedulers：调度器 解决Android主线程问题
通过Rxjava和RxAndroid实现的EventBus
沐雨清风
10-14 370
初次探索，可能会有很多问题，需要慢慢修改！ 依赖第三方库：Rxjava和RxAndroid      compile 'io.reactivex:rxjava:1.1.5' compile 'io.reactivex:rxandroid:1.2.0' /** * 通过rxjava、rxandroid实现EventBus功能 * 使用方式： * 1、注册时返回一个Obser
RxJava与RxAndroid的学习之路
weixin_34342207的博客
03-11 64
RxJava 和 RxAndroid 四（RxBinding的使用） 对Rxjava不熟悉的同学可以先看我之前写的几篇文章RxJava 和 RxAndroid 一 (基础)RxJava 和 RxAndroid 二（操作符的使用）RxJava 和 RxAndroid 三（生命周期控制和内存优化）另外推荐几篇比较好的文章，有助于理解Rxjava安卓客户端是如何使用 Rx...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值