RxJava和rx.exceptions.MissingBackpressureException异常

我正在尝试让一个非常基本的基于RxJava的应用程序工作。我定义了以下可观察类，它从文件中读取并返回行：

public Observable<String> getObservable() throws IOException
    {
        return Observable.create(subscribe -> {
            InputStream in = getClass().getResourceAsStream("/trial.txt");
            BufferedReader reader = new BufferedReader(new InputStreamReader(in));
            String line = null;
            try {
                while((line = reader.readLine()) != null)
                {
                    subscribe.onNext(line);
                }
            } catch (IOException e) {
                subscribe.onError(e);
            }
            finally {
                subscribe.onCompleted();
            }
        });
    }

该文件有近50000条记录。运行应用程序时，我收到rx.exceptions.MissingBackpressureException。我已经阅读了一些文档，并且按照建议，我尝试在调用链中添加.onBackpressureBuffer方法。但是我没有得到例外，但是完成的电话也没有被解雇

处理快速生成observeOn的场景的正确方法是什么？

这里的问题是observeOn操作符，因为每个observeOn操作符的onNext调用被安排在一个单独的线程上调用，所以无论用户observeOn的容量如何，observeOn都会在一个循环中生成这些预定调用

如果您保持这个同步，Observable将不会发出下一个元素，直到subscriber处理完前一个元素，因为它都是在一个线程上完成的，您将不再有背压问题

---

如果仍要使用observeOn，则必须在Observable的OnSubscribecall方法中实现背压逻辑。第一个问题是，您的readLine逻辑忽略了背压。您可以在observeOn开始之前应用onBackpressureBuffer，但最近添加了一个SyncOnSubscribe，让您逐个生成值并处理背压：

SyncOnSubscribe.createSingleState(() => {
    try {
        InputStream in = getClass().getResourceAsStream("/trial.txt");
        return new BufferedReader(new InputStreamReader(in));
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
},
(s, o) -> {
    try {
        String line = s.readLine();
        if (line == null) {
            o.onCompleted();
        } else {
            o.onNext(line);
        }
    } catch (IOException ex) {
        s.onError(ex);
    }
},
s -> {
    try {
       s.close();
    } catch (IOException ex) {
    }
});

第二个问题是，您的线程将在io线程上的所有元素被交付之前完成，因此主程序将退出。移除observeOn、添加.ToBlock或使用倒计时闩锁

---

SyncOnSubscribe是最新RxJava包的一部分吗？我有1.0.8版本的RxJava框架？明白了。包括最新版本1.1.0和SyncOnSubscribe类。这是一个很老的版本，但是为了摆脱观察，我解决了背压问题，你能详细说明一下为什么这样做吗？我可以感觉到，一个可观察的应该能够对多个线程执行相同的操作

SyncOnSubscribe.createSingleState(() => {
    try {
        InputStream in = getClass().getResourceAsStream("/trial.txt");
        return new BufferedReader(new InputStreamReader(in));
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
},
(s, o) -> {
    try {
        String line = s.readLine();
        if (line == null) {
            o.onCompleted();
        } else {
            o.onNext(line);
        }
    } catch (IOException ex) {
        s.onError(ex);
    }
},
s -> {
    try {
       s.close();
    } catch (IOException ex) {
    }
});

RxObserver observer = new RxObserver();
try {

    CountDownLatch cdl = new CountDownLatch(1);

    observer.getObservable()
           .observeOn(Schedulers.io())
           .subscribe( x ->System.out.println(x),
                       t -> { System.out.println(t); cdl.countDown(); },
                       () -> { System.out.println("Completed"); cdl.countDown(); });

    cdl.await();
 } catch (IOException | InterruptedException e) {
     e.printStackTrace();
 }