Java RxAndroid与多线程

我正在使用RxAndroid在后台做一些事情。这是我的代码：

Observable<MyClass[]> observable = Observable.create(new Observable.OnSubscribe<MyClass[]>() {

        @Override
        public void call(Subscriber<? super MyClass[]> subscriber) {
                System.out.println(Looper.myLooper() + " - " + Looper.getMainLooper());
                try {
                    MyObject myObject = ...
                    //do the background work
                    subscriber.onNext(myObject);
                    subscriber.onCompleted();
                } catch (Exception e) {
                    subscriber.onError(e);
                    e.printStackTrace();
                }
            }
        });

        observable.subscribeOn(Schedulers.newThread())
                  .observeOn(AndroidSchedulers.mainThread())
                  .subscribe(new Action1<MyClass[]>() {
                      @Override
                      public void call(MyClass[] myObjects) {
                          //do work on the ui Thread
                      }
                  }
        );

Observable-Observable=Observable.create（new Observable.OnSubscribe（））{
@凌驾
public void call（订户建议您不要使用
Observable.create
，除非您确实知道如何使用Observable。有很多事情可能会出错

create中的代码在这里的主线程上运行的原因是，在创建可观察对象时调用它，而不是在订阅时调用它

对于您试图实现的目标，我将使用
Observable.defer
：

延迟操作符等待观测者订阅它，然后它生成一个可观察的，通常带有一个可观察工厂函数

代码将类似于：

Observable<MyObject> observable = Observable.defer(new Func0<Observable<MyObject>>() {
    @Override
    public Observable<MyObject> call() {

        System.out.println(Looper.myLooper() + " - " + Looper.getMainLooper());

        try {
            MyObject myObject = new MyObject();
            return Observable.just(myObject);
        }
        catch (Exception e) {
            return Observable.error(e);
        }

    }
});

Subscription s = observable
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(
                new Action1<MyObject>() {
                    @Override
                    public void call(MyObject myObject) {

                    }
                },
                new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        throwable.printStackTrace();
                    }
                }
        );

Looper.myLooper（）
函数返回null的原因是创建新线程时，除非调用
Looper.prepare（）
线程不会有活套。通常情况下，线程上不需要活套，除非你想将
Runnable
发布到线程上。
建议你不要使用
Observable。创建
，除非你真的知道你在用Observable做什么。有很多事情可能会出错。

create中的代码在这里的主线程上运行的原因是，在创建可观察对象时调用它，而不是在订阅时调用它

对于您试图实现的目标，我将使用
Observable.defer
：

延迟操作符等待观测者订阅它，然后它生成一个可观察的，通常带有一个可观察工厂函数

代码将类似于：

Observable<MyObject> observable = Observable.defer(new Func0<Observable<MyObject>>() {
    @Override
    public Observable<MyObject> call() {

        System.out.println(Looper.myLooper() + " - " + Looper.getMainLooper());

        try {
            MyObject myObject = new MyObject();
            return Observable.just(myObject);
        }
        catch (Exception e) {
            return Observable.error(e);
        }

    }
});

Subscription s = observable
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(
                new Action1<MyObject>() {
                    @Override
                    public void call(MyObject myObject) {

                    }
                },
                new Action1<Throwable>() {
                    @Override
                    public void call(Throwable throwable) {
                        throwable.printStackTrace();
                    }
                }
        );

Looper.myLooper（）
函数返回null的原因是创建新线程时，除非调用
Looper.prepare（）
线程不会有活套。除非你想在线程上发布一个
可运行的
。
嘿。对不起。已经离开一段时间了。我今晚会试试这个，然后给你回复：）嘿。对不起。离开一段时间了。我今晚会试试这个，然后回复你：）