RxJava2.0(二)Schedulers线程调度器

36 篇文章 0 订阅

前言

上一节教程讲解了最基本的RxJava2的使用, 在本节中, 我们将学习RxJava强大的线程控制Schedulers.

正题

还是以之前的例子, 两根水管:

正常情况下, 上游和下游是工作在同一个线程中的, 也就是说上游在哪个线程发事件, 下游就在哪个线程接收事件.

当我们在主线程中去创建一个上游Observable来发送事件, 则这个上游默认就在主线程发送事件. 

当我们在主线程去创建一个下游Observer来接收事件, 则这个下游默认就在主线程中接收事件, 来看段代码:

@Override                                                                                       
protected void onCreate(Bundle savedInstanceState) {                                            
    super.onCreate(savedInstanceState);                                                         
    setContentView(R.layout.activity_main);                                                     
                                                                          
    Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {   
        @Override                                                                               
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {            
            Log.d(TAG, "Observable thread is : " + Thread.currentThread().getName());           
            Log.d(TAG, "emit 1");                                                               
            emitter.onNext(1);                                                                  
        }                                                                                       
    });                                                                                         
                                                                                                
    Consumer<Integer> consumer = new Consumer<Integer>() {                                      
        @Override                                                                               
        public void accept(Integer integer) throws Exception {                                  
            Log.d(TAG, "Observer thread is :" + Thread.currentThread().getName());              
            Log.d(TAG, "onNext: " + integer);                                                   
        }                                                                                       
    };                                                                                          
                                                                                                
    observable.subscribe(consumer);                                                             
}  

//运行结果
D/TAG: Observable thread is : main
D/TAG: emit 1                     
D/TAG: Observer thread is :main   
D/TAG: onNext: 1                                       

这就验证了刚才所说, 上下游默认是在同一个线程工作.

这样肯定是满足不了我们的需求的, 我们更多想要的是这么一种情况, 在子线程中做耗时的操作, 然后回到主线程中来操作UI, 用图片来描述就是下面这个图片:

在这个图中, 我们用黄色水管表示子线程, 深蓝色水管表示主线程.

要达到这个目的, 我们需要先改变上游发送事件的线程, 让它去子线程中发送事件, 然后再改变下游的线程, 让它去主线程接收事件. 通过RxJava内置的线程调度器可以很轻松的做到这一点. 接下来看一段代码:

@Override                                                                                       
protected void onCreate(Bundle savedInstanceState) {                                            
    super.onCreate(savedInstanceState);                                                         
    setContentView(R.layout.activity_main);                                                     
                                                                                                
    Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {   
        @Override                                                                               
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {            
            Log.d(TAG, "Observable thread is : " + Thread.currentThread().getName());           
            Log.d(TAG, "emit 1");                                                               
            emitter.onNext(1);                                                                  
        }                                                                                       
    });                                                                                         
                                                                                                
    Consumer<Integer> consumer = new Consumer<Integer>() {                                      
        @Override                                                                               
        public void accept(Integer integer) throws Exception {                                  
            Log.d(TAG, "Observer thread is :" + Thread.currentThread().getName());              
            Log.d(TAG, "onNext: " + integer);                                                   
        }                                                                                       
    };                                                                                          
                                                                                                
    observable.subscribeOn(Schedulers.newThread())                                              
            .observeOn(AndroidSchedulers.mainThread())                                          
            .subscribe(consumer);                                                               
}   

//运行结果
 D/TAG: Observable thread is : RxNewThreadScheduler-2  
 D/TAG: emit 1                                         
 D/TAG: Observer thread is :main                       
 D/TAG: onNext: 1                   

简单的来说, subscribeOn() 指定的是上游发送事件的线程, observeOn() 指定的是下游接收事件的线程.

在多次指定上游线程环境的情况下,是只有第一次指定的才有效, 也就是说多次调用subscribeOn() 只有第一次的有效, 其余的会被忽略.同时subscribeOn()的位置可以写在任何地方。

多次指定下游的线程是可以的, 也就是说每调用一次observeOn() , 下游的线程就会切换一次.

举个例子:

 observable.subscribeOn(Schedulers.newThread())     
         .subscribeOn(Schedulers.io())              
         .observeOn(AndroidSchedulers.mainThread()) 
         .observeOn(Schedulers.io())                
         .subscribe(consumer);     

上游虽然指定了两次线程, 但只有第一次指定的有效, 而下游则跑到了IO线程中.

RxJava内置的线程调度器Schedulers

  • Schedulers.immediate() : 默认的 Scheduler,直接在当前线程运行,相当于不指定线程。
  • Schedulers.newThread():总是启用新线程,并在新线程中执行操作。
  • Schedulers.io():                (读写文件、读写数据库、网络请求) I/O操作使用的Scheduler。                                             它的行为模式和 newTherad() 差不多,区别在于io() 的内部实现了                                            无数量上线的线程池,可以重用空闲的线程,因此多数情况下 io()                                           比 newThread() 更有效率。注意:不要把计算相关的工作放在 io()                                           中,可以避免创建不必要的线程。
  • Schedulers.computation():计算所使用的 Scheduler。这里的计算指的是 CPU 密集型计算,                                               即不会被 I/O 等操作限制性能的操作,例如图形的计算。                                                           它使用了一个固定的线程池,大小为CPU核心数。                                                                    不要在这种调度器中执行I/O,否则等待的时间会浪费CPU。
  • Schedulers.mainThread(): 它指定的操作将在UI主线程中执行。

这些内置的Scheduler已经足够满足我们开发的需求, 因此我们应该使用内置的这些选项, 在RxJava内部使用的是线程池来维护这些线程, 所有效率也比较高.

实践

对于我们Android开发人员来说, 经常会将一些耗时的操作放在后台, 比如网络请求或者读写文件,操作数据库等等,等到操作完成之后回到主线程去更新UI, 有了上面的这些基础, 那么现在我们就可以轻松的去做到这样一些操作.

下面来举几个常用的场景.

网络请求

Android中有名的网络请求库就那么几个, Retrofit能够从中脱颖而出很大原因就是因为它支持RxJava的方式来调用, 下面简单讲解一下它的基本用法.

1. 要使用Retrofit,先添加Gradle配置:

    //retrofit
    compile 'com.squareup.retrofit2:retrofit:2.1.0'
    //Gson converter
    compile 'com.squareup.retrofit2:converter-gson:2.1.0'
    //RxJava2 Adapter
    compile 'com.jakewharton.retrofit:retrofit2-rxjava2-adapter:1.0.0'
    //okhttp
    compile 'com.squareup.okhttp3:okhttp:3.4.1'
    compile 'com.squareup.okhttp3:logging-interceptor:3.4.1'

2. 随后定义Api接口: 

public interface Api {
    @GET
    Observable<LoginResponse> login(@Body LoginRequest request);

    @GET
    Observable<RegisterResponse> register(@Body RegisterRequest request);
}

3. 接着创建一个Retrofit客户端:

private static Retrofit create() {
     OkHttpClient.Builder builder = new OkHttpClient().newBuilder();
     builder.readTimeout(10, TimeUnit.SECONDS);
     builder.connectTimeout(9, TimeUnit.SECONDS);
     if (BuildConfig.DEBUG) {
         HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
         interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
         builder.addInterceptor(interceptor);
     }
     return new Retrofit.Builder().baseUrl(ENDPOINT)
              .client(builder.build())
              .addConverterFactory(GsonConverterFactory.create())
              .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
              .build();
}

4. 发起请求就很简单了:

Api api = retrofit.create(Api.class);
api.login(request)
   .subscribeOn(Schedulers.io())               //在IO线程进行网络请求
   .observeOn(AndroidSchedulers.mainThread())  //回到主线程去处理请求结果
   .subscribe(new Observer<LoginResponse>() {
      @Override
      public void onSubscribe(Disposable d) {}

      @Override
      public void onNext(LoginResponse value) {}

      @Override
      public void onError(Throwable e) {
           Toast.makeText(mContext, "登录失败", Toast.LENGTH_SHORT).show();
      }

      @Override
      public void onComplete() {
           Toast.makeText(mContext, "登录成功", Toast.LENGTH_SHORT).show();
      }
    });

看似很完美, 但我们忽略了一点, 如果在请求的过程中Activity已经退出了, 这个时候如果回到主线程去更新UI, 那么APP肯定就崩溃了, 怎么办呢, 上一节我们说到了Disposable , 说它是个开关, 调用它的dispose()方法时就会切断水管, 使得下游收不到事件, 既然收不到事件, 那么也就不会再去更新UI了. 因此我们可以在Activity中将这个Disposable 保存起来, 当Activity退出时, 切断它即可.

那如果有多个Disposable 该怎么办呢, RxJava中已经内置了一个容器CompositeDisposable, 每当我们得到一个Disposable时就调用CompositeDisposable.add()将它添加到容器中, 在退出的时候, 调用CompositeDisposable.clear() 即可切断所有的水管.

读写数据库

上面说了网络请求的例子, 接下来再看看读写数据库, 读写数据库也算一个耗时的操作, 因此我们也最好放在IO线程里去进行, 这个例子就比较简单, 直接上代码:

public Observable<List<Record>> readAllRecords() {
    return Observable.create(new ObservableOnSubscribe<List<Record>>() {
        @Override
        public void subscribe(ObservableEmitter<List<Record>> emitter) throws Exception {
            Cursor cursor = null;
            try {
                cursor = getReadableDatabase().rawQuery("select * from " + TABLE_NAME, new String[]{});
                List<Record> result = new ArrayList<>();
                while (cursor.moveToNext()) {
                      result.add(Db.Record.read(cursor));
                }
                emitter.onNext(result);
                emitter.onComplete();
             } finally {
                 if (cursor != null) {
                     cursor.close();
                 }
             }
         }
    })
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread());
}

好了本次的教程就到这里吧, 后面的教程将会教大家如何使用RxJava中强大的操作符. 通过使用这些操作符可以很轻松的做到各种吊炸天的效果. 敬请期待.

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android 中,使用 RxJava 可以非常方便地实现线程切换。RxJava 提供了几个操作符用于实现线程切换,包括 `subscribeOn()` 和 `observeOn()`。 `subscribeOn()` 操作符用于指定被观察者的执行线程,而 `observeOn()` 操作符用于指定观察者的执行线程。这两个操作符可以组合使用,实现从一个线程切换到另一个线程的功能。 下面是一个简单的 RxJava 实现多线程的例子: ```java Observable.create(new ObservableOnSubscribe<Integer>() { @Override public void subscribe(ObservableEmitter<Integer> emitter) throws Exception { // 在子线程中执行耗时操作 Log.d("RxJava", "subscribe: " + Thread.currentThread().getName()); emitter.onNext(1); emitter.onComplete(); } }) .subscribeOn(Schedulers.newThread()) // 指定被观察者的执行线程 .observeOn(AndroidSchedulers.mainThread()) // 指定观察者的执行线程 .subscribe(new Observer<Integer>() { @Override public void onSubscribe(Disposable d) { // 订阅事件 } @Override public void onNext(Integer integer) { // 处理事件 Log.d("RxJava", "onNext: " + Thread.currentThread().getName()); } @Override public void onError(Throwable e) { // 处理错误 } @Override public void onComplete() { // 完成事件 } }); ``` 在上面的代码中,使用 `subscribeOn()` 操作符指定被观察者在新线程中执行,使用 `observeOn()` 操作符指定观察者在主线程中执行。在实际开发中,可以根据实际需求选择不同的线程。 需要注意的是,RxJava 中的线程切换并不会创建新的线程,而是复用已有的线程。因此,如果需要在多个地方使用 RxJava 进行线程切换,建议使用线程池来管理线程,避免创建过多的线程

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值