1. 程式人生 > >android RXJava2.0(二)--執行緒控制

android RXJava2.0(二)--執行緒控制

正題

還是以之前的例子, 兩根水管:

正常情況下, 上游和下游是工作在同一個執行緒中的, 也就是說上游在哪個執行緒發事件, 下游就在哪個執行緒接收事件.

怎麼去理解呢, 以Android為例, 一個Activity的所有動作預設都是在主執行緒中執行的, 比如我們在onCreate中打出當前執行緒的名字:

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

結果便是:

D/TAG: main

回到RxJava中, 當我們在主執行緒中去建立一個上游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

可以看到, 上游傳送事件的執行緒的確改變了, 是在一個叫 RxNewThreadScheduler-2的執行緒中傳送的事件, 而下游仍然在主執行緒中接收事件, 這說明我們的目的達成了, 接下來看看是如何做到的.

和上一段程式碼相比,這段程式碼只不過是增加了兩行程式碼:

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

作為一個初學者的入門教程, 並不會貼出一大堆原始碼來分析, 因此只需要讓大家記住幾個要點, 已達到如何正確的去使用這個目的才是我們的目標.

簡單的來說, subscribeOn() 指定的是上游傳送事件的執行緒, observeOn() 指定的是下游接收事件的執行緒.

多次指定上游的執行緒只有第一次指定的有效, 也就是說多次呼叫subscribeOn() 只有第一次的有效, 其餘的會被忽略.

多次指定下游的執行緒是可以的, 也就是說每呼叫一次observeOn() , 下游的執行緒就會切換一次.

舉個例子:

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

這段程式碼中指定了兩次上游傳送事件的執行緒, 分別是newThread和IO執行緒, 下游也指定了兩次執行緒,分別是main和IO執行緒. 執行結果為:

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

可以看到, 上游雖然指定了兩次執行緒, 但只有第一次指定的有效, 依然是在 RxNewThreadScheduler 執行緒中, 而下游則跑到了 RxCachedThreadScheduler 中, 這個 CacheThread 其實就是 IO 執行緒池中的一個.

為了更清晰的看到下游的執行緒切換過程, 我們加點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/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

可以看到, 每呼叫一次 observeOn() 執行緒便會切換一次, 因此如果我們有類似的需求時, 便可知道如何處理了.

在RxJava中, 已經內建了很多執行緒選項供我們選擇, 例如有

  • Schedulers.io() 代表io操作的執行緒, 通常用於網路,讀寫檔案等io密集型的操作
  • Schedulers.computation() 代表CPU計算密集型的操作, 例如需要大量計算的操作
  • Schedulers.newThread() 代表一個常規的新執行緒
  • AndroidSchedulers.mainThread() 代表Android的主執行緒
    這些內建的Scheduler已經足夠滿足我們開發的需求, 因此我們應該使用內建的這些選項, 在RxJava內部使用的是執行緒池來維護這些執行緒, 所有效率也比較高.

實踐

對於我們Android開發人員來說, 經常會將一些耗時的操作放在後臺, 比如網路請求或者讀寫檔案,操作資料庫等等,等到操作完成之後回到主執行緒去更新UI, 有了上面的這些基礎, 那麼現在我們就可以輕鬆的去做到這樣一些操作.

下面來舉幾個常用的場景.

網路請求

Android中有名的網路請求庫就那麼幾個, Retrofit能夠從中脫穎而出很大原因就是因為它支援RxJava的方式來呼叫, 下面簡單講解一下它的基本用法.

要使用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);
}

接著建立一個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();
}

發起請求就很簡單了:

    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中強大的操作符. 通過使用這些操作符可以很輕鬆的做到各種吊炸天的效果. 敬請期待.

自己總結


  1. 執行緒切換
    1. 一次onSubscribe
    2. 多次onObserver
  2. 使用dispose()切斷下游

mDisposable.dispose();
// mCompositeDisposable.clear(); //當有多個disposabele的時候全部清空