本文轉(zhuǎn)載自http://www.itdecent.cn/p/8818b98c44e2

前言

上一節(jié)教程講解了最基本的RxJava2的使用, 在本節(jié)中, 我們將學(xué)習(xí)RxJava強(qiáng)大的線程控制.
正題
還是以之前的例子, 兩根水管:

正常情況下, 上游和下游是工作在同一個(gè)線程中的, 也就是說上游在哪個(gè)線程發(fā)事件, 下游就在哪個(gè)線程接收事件.
怎么去理解呢, 以Android為例, 一個(gè)Activity的所有動(dòng)作默認(rèn)都是在主線程中運(yùn)行的, 比如我們在onCreate中打出當(dāng)前線程的名字:

 @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG, Thread.currentThread().getName());
    }

結(jié)果便是:

D/TAG: main

回到RxJava中, 當(dāng)我們在主線程中去創(chuàng)建一個(gè)上游Observable來發(fā)送事件, 則這個(gè)上游默認(rèn)就在主線程發(fā)送事件.
當(dāng)我們在主線程去創(chuàng)建一個(gè)下游Observer來接收事件, 則這個(gè)下游默認(rèn)就在主線程中接收事件, 來看段代碼:

@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);                                                             
}

在主線程中分別創(chuàng)建上游和下游, 然后將他們連接在一起, 同時(shí)分別打印出它們所在的線程, 運(yùn)行結(jié)果為:

D/TAG: Observable thread is : main
D/TAG: emit 1                     
D/TAG: Observer thread is :main   
D/TAG: onNext: 1

這就驗(yàn)證了剛才所說, 上下游默認(rèn)是在同一個(gè)線程工作.
這樣肯定是滿足不了我們的需求的, 我們更多想要的是這么一種情況, 在子線程中做耗時(shí)的操作, 然后回到主線程中來操作UI, 用圖片來描述就是下面這個(gè)圖片:

在這個(gè)圖中, 我們用黃色水管表示子線程, 深藍(lán)色水管表示主線程.
要達(dá)到這個(gè)目的, 我們需要先改變上游發(fā)送事件的線程, 讓它去子線程中發(fā)送事件, 然后再改變下游的線程, 讓它去主線程接收事件. 通過RxJava內(nèi)置的線程調(diào)度器可以很輕松的做到這一點(diǎn). 接下來看一段代碼:

@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);                                                               
}

還是剛才的例子, 只不過我們太添加了一點(diǎn)東西, 先來看看運(yùn)行結(jié)果:

 D/TAG: Observable thread is : RxNewThreadScheduler-2  
 D/TAG: emit 1                                         
 D/TAG: Observer thread is :main                       
 D/TAG: onNext: 1

可以看到, 上游發(fā)送事件的線程的確改變了, 是在一個(gè)叫 RxNewThreadScheduler-2
的線程中發(fā)送的事件, 而下游仍然在主線程中接收事件, 這說明我們的目的達(dá)成了, 接下來看看是如何做到的.
和上一段代碼相比,這段代碼只不過是增加了兩行代碼:

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

作為一個(gè)初學(xué)者的入門教程, 并不會(huì)貼出一大堆源碼來分析, 因此只需要讓大家記住幾個(gè)要點(diǎn), 已達(dá)到如何正確的去使用這個(gè)目的才是我們的目標(biāo).
簡單的來說, subscribeOn()
指定的是上游發(fā)送事件的線程, observeOn()
指定的是下游接收事件的線程.
多次指定上游的線程只有第一次指定的有效, 也就是說多次調(diào)用subscribeOn()
只有第一次的有效, 其余的會(huì)被忽略.
多次指定下游的線程是可以的, 也就是說每調(diào)用一次observeOn()
, 下游的線程就會(huì)切換一次.
舉個(gè)例子:

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

這段代碼中指定了兩次上游發(fā)送事件的線程, 分別是newThread和IO線程, 下游也指定了兩次線程,分別是main和IO線程. 運(yùn)行結(jié)果為:

D/TAG: Observable thread is : RxNewThreadScheduler-3
D/TAG: emit 1                                       
D/TAG: Observer thread is :RxCachedThreadScheduler-1
D/TAG: onNext: 1

可以看到, 上游雖然指定了兩次線程, 但只有第一次指定的有效, 依然是在RxNewThreadScheduler
線程中, 而下游則跑到了RxCachedThreadScheduler
中, 這個(gè)CacheThread其實(shí)就是IO線程池中的一個(gè).
為了更清晰的看到下游的線程切換過程, 我們加點(diǎn)log:

   observable.subscribeOn(Schedulers.newThread())
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "After observeOn(mainThread), current thread is: " + Thread.currentThread().getName());
                    }
                })
                .observeOn(Schedulers.io())
                .doOnNext(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.d(TAG, "After observeOn(io), current thread is : " + Thread.currentThread().getName());
                    }
                })
                .subscribe(consumer);

我們在下游線程切換之后, 把當(dāng)前的線程打印出來, 運(yùn)行結(jié)果:

D/TAG: Observable thread is : RxNewThreadScheduler-1                                             
D/TAG: emit 1                                                                                    
D/TAG: After observeOn(mainThread), current thread is: main                                      
D/TAG: After observeOn(io), current thread is : RxCachedThreadScheduler-2                        
D/TAG: Observer thread is :RxCachedThreadScheduler-2                                             
D/TAG: onNext: 1

可以看到, 每調(diào)用一次observeOn()
線程便會(huì)切換一次, 因此如果我們有類似的需求時(shí), 便可知道如何處理了.
在RxJava中, 已經(jīng)內(nèi)置了很多線程選項(xiàng)供我們選擇, 例如有
Schedulers.io() 代表io操作的線程, 通常用于網(wǎng)絡(luò),讀寫文件等io密集型的操作
Schedulers.computation() 代表CPU計(jì)算密集型的操作, 例如需要大量計(jì)算的操作
Schedulers.newThread() 代表一個(gè)常規(guī)的新線程
AndroidSchedulers.mainThread() 代表Android的主線程

這些內(nèi)置的Scheduler已經(jīng)足夠滿足我們開發(fā)的需求, 因此我們應(yīng)該使用內(nèi)置的這些選項(xiàng), 在RxJava內(nèi)部使用的是線程池來維護(hù)這些線程, 所有效率也比較高.

實(shí)踐

對于我們Android開發(fā)人員來說, 經(jīng)常會(huì)將一些耗時(shí)的操作放在后臺, 比如網(wǎng)絡(luò)請求或者讀寫文件,操作數(shù)據(jù)庫等等,等到操作完成之后回到主線程去更新UI, 有了上面的這些基礎(chǔ), 那么現(xiàn)在我們就可以輕松的去做到這樣一些操作.
下面來舉幾個(gè)常用的場景.

網(wǎng)絡(luò)請求

Android中有名的網(wǎng)絡(luò)請求庫就那么幾個(gè), Retrofit能夠從中脫穎而出很大原因就是因?yàn)樗С諶xJava的方式來調(diào)用, 下面簡單講解一下它的基本用法.
要使用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'

隨后定義Api接口:

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

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

接著創(chuàng)建一個(gè)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();
}

發(fā)起請求就很簡單了:

        Api api = retrofit.create(Api.class);
        api.login(request)
              .subscribeOn(Schedulers.io())               //在IO線程進(jìn)行網(wǎng)絡(luò)請求
             .observeOn(AndroidSchedulers.mainThread())  //回到主線程去處理請求結(jié)果
            .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();
                }
            });

看似很完美, 但我們忽略了一點(diǎn), 如果在請求的過程中Activity已經(jīng)退出了, 這個(gè)時(shí)候如果回到主線程去更新UI, 那么APP肯定就崩潰了, 怎么辦呢, 上一節(jié)我們說到了Disposable
, 說它是個(gè)開關(guān), 調(diào)用它的dispose()
方法時(shí)就會(huì)切斷水管, 使得下游收不到事件, 既然收不到事件, 那么也就不會(huì)再去更新UI了. 因此我們可以在Activity中將這個(gè)Disposable
保存起來, 當(dāng)Activity退出時(shí), 切斷它即可.
那如果有多個(gè)Disposable
該怎么辦呢, RxJava中已經(jīng)內(nèi)置了一個(gè)容器CompositeDisposable
, 每當(dāng)我們得到一個(gè)Disposable
時(shí)就調(diào)用CompositeDisposable.add()
將它添加到容器中, 在退出的時(shí)候, 調(diào)用CompositeDisposable.clear()
即可切斷所有的水管.

讀寫數(shù)據(jù)庫

上面說了網(wǎng)絡(luò)請求的例子, 接下來再看看讀寫數(shù)據(jù)庫, 讀寫數(shù)據(jù)庫也算一個(gè)耗時(shí)的操作, 因此我們也最好放在IO線程里去進(jìn)行, 這個(gè)例子就比較簡單, 直接上代碼:

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());
    }

好了本次的教程就到這里吧, 后面的教程將會(huì)教大家如何使用RxJava中強(qiáng)大的操作符. 通過使用這些操作符可以很輕松的做到各種吊炸天的效果. 敬請期待.