RxJava：Observable和默認線程

Question

我有以下代碼：

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull final ObservableEmitter<String> s) throws Exception {
                Thread thread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        s.onNext("1");
                        s.onComplete();
                    }
                });
                thread.setName("background-thread-1");
                thread.start();
            }
        }).map(new Function<String, String>() {
            @Override
            public String apply(@NonNull String s) throws Exception {
                String threadName = Thread.currentThread().getName();
                logger.logDebug("map: thread=" + threadName);
                return "map-" + s;
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {}

            @Override
            public void onNext(String s) {
                String threadName = Thread.currentThread().getName();
                logger.logDebug("onNext: thread=" + threadName + ", value=" + s);
            }

            @Override
            public void onError(Throwable e) {}

            @Override
            public void onComplete() {
                String threadName = Thread.currentThread().getName();
                logger.logDebug("onComplete: thread=" + threadName);
            }
        });

這是輸出：

map: thread=background-thread-1 
onNext: thread=background-thread-1, value=map-1 
onComplete: thread=background-thread-1

重要細節：我從另一個線程（Android中的main線程）調用subscribe方法。

所以看起來Observable類是同步的，默認情況下它會在發出事件的同一個線程（ s.onNext ）上執行所有操作（如map +通知訂閱者），對嗎？ 我想知道......它是故意的行為還是我誤解了什么？ 實際上我期待至少onNext和onComplete回調將在調用者的線程上調用，而不是在一個發射事件上。 我是否正確理解在這種特殊情況下，實際來電者的線程無關緊要？ 至少在異步生成事件時。

另一個問題 - 如果我從一些外部源接收一些Observable作為參數（即我不自己生成它）...如果我的用戶無法檢查它是同步還是異步，我只需要通過subscribeOn和observeOn方法明確指定我想要接收回調的observeOn ，對吧？

謝謝！

Answer 1

RxJava對並發性沒有任何意見。 如果您不使用observeOn / subscribeOn之類的任何其他機制，它將在訂閱線程上生成值。 請不要在運算符中使用Thread之類的低級構造，否則可能會違反合同。

由於使用了Thread，onNext將從調用Thread（'background-thread-1'）調用。 訂閱發生在調用（UI-Thread）上。 鏈中的每個運算符都將從'background-thread-1'-calling-Thread調用。 訂閱onNext也將從'background-thread-1'調用。

如果要生成不在調用線程上的值，請使用：subscribeOn。 如果要將線程切換回主要，請在鏈中的某處使用observeOn。 最有可能在訂閱它之前。

例：

Observable.just(1,2,3) // creation of observable happens on Computational-Threads
            .subscribeOn(Schedulers.computation()) // subscribeOn happens only once in chain. Nearest to source wins
            .map(integer -> integer) // map happens on Computational-Threads
            .observeOn(AndroidSchedulers.mainThread()) // Will switch every onNext to Main-Thread
            .subscribe(integer -> {
                // called from mainThread
            });

這是一個很好的解釋。 http://tomstechnicalblog.blogspot.de/2016/02/rxjava-understanding-observeon-and.html