可观察的不是异步的

Question

我正在学习RxJava并正在测试从数据库读取数据，然后将其发布到队列的方案。 我只是对整个过程进行了模拟，但我似乎找不到我想要的Observable工作。 异步地。

这是我的代码：

package rxJava;

import java.util.ArrayList;
import java.util.List;

import rx.Observable;
import rx.Observer;
import rx.functions.Action1;

public class TestClass {

    public static void main(String[] args) {

        TestClass test = new TestClass();
        System.out.println("---START---");

        test.getFromDB().subscribe(new Observer<String>() {

            @Override
            public void onCompleted() {
                System.out.println("Publish complete.");
            }

            @Override
            public void onError(Throwable t) {
                System.out.println(t.getMessage());
            }

            @Override
            public void onNext(String s) {
                test.publishToQueue(s).subscribe(new Observer<Boolean>() {

                    @Override
                    public void onNext(Boolean b) {
                        if (b) {
                            System.out.println("Successfully published.");
                        }
                    }

                    @Override
                    public void onCompleted() {
                    }

                    @Override
                    public void onError(Throwable arg0) {
                    }
                });
            };
        });
        System.out.println("---END---");
    }

    public Observable<String> getFromDB() {

        List<String> list = new ArrayList<String>();
        for (int i = 0; i < 30; i++) {
            list.add(Integer.toString(i));
        }
        return Observable.from(list).doOnNext(new Action1<String>() {
            @Override
            public void call(String temp) {
                if (temp.contains("2")) {
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });

    }

    public Observable<Boolean> publishToQueue(String s) {

        return Observable.defer(() -> {
            try {
                if (s.contains("7")) {
                    Thread.sleep(700);
                }
                System.out.println("Published:: " + s);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return Observable.just(true);
        });
    }
}

假设我异步地从数据库获取列表，并希望将其发布到队列中。 我使用了一个从getFromDB返回的Observable ，并订阅了它，它模仿了我从DB获取的数据。 每次从数据库获取数据时，我都想使用publishToQueue将其推送到队列，该队列还返回一个Observable 。 我想使队列调用也异步。 现在，从队列肯定的确认，如Boolean ，我是回（ Observable<Boolean> ），我想打印的东西。

所以基本上我只希望两个过程都是异步的。 对于数据库中的每个数据，我都将其异步推送到队列。

我在两种方法（数据库调用和队列Thread.sleep()中都添加了Thread.sleep() ，以便模拟延迟并测试异步操作。 我认为这是导致问题的原因。 但是我也尝试了Obseravable.delay()但是它甚至不会产生任何输出。

请帮助我了解它的工作原理以及如何使其按我的意愿工作。

Answer 1

您必须指定subscribeOn值。

Observable.just("one", "two", "three", "four", "five")
        .subscribeOn(Schedulers.newThread())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(/* an Observer */);

http://reactivex.io/documentation/operators/subscribeon.html

Answer 2

默认情况下，RxJava是同步的 。 这意味着默认情况下，所有操作都将在同一线程（和当前线程）中执行。 您可以observeOn / subscribeOn方法在另一个线程中执行任务，或者使用一些在另一个作业中执行任务的运算符（因为它使用另一个调度程序，例如delay ， interval ，...）

在您的示例中，您必须明确设置将在哪个调度程序中执行订阅。 （在这里， Observable.from线程将在其中发出您的列表）

test.getFromDb()
    .subscribeOn(Schedulers.io())
    .subscribe();

然后，您可以使用flatMap运算符并调用publishToQueue方法。 该方法将在先前的调度程序中执行，但是由于使用了observeOn方法，您可以强制其使用另一个调度程序。 observeOn方法之后的所有内容都将在另一个线程中执行。

 test.fromDb()
     .subscribeOn(Schedulers.io())
     .observeOn(Schedulers.computation())
     .flatMap(l -> test.publishToqueue(l))
     .subscribe();