Rx java 如何从自己线程中调用的回调创建可观察的

我尝试为nu进程（非阻塞进程执行）创建RXJava包装器。并尝试为std out创建

可观察的
：

static Observable<byte[]> process(List<String> cmd) {
    return Observable.create(emitter -> {

        NuProcessBuilder b = new NuProcessBuilder(cmd);
        b.setProcessListener(new NuAbstractProcessHandler() {
            @Override
            public void onStdout(ByteBuffer buffer, boolean closed) {
                //calls on NuProcess thread
                byte[] bytes = new byte[buffer.remaining()];
                buffer.get(bytes);
                emitter.onNext(bytes);
            }

            @Override
            public void onExit(int statusCode) {
                //calls on NuProcess thread
                emitter.onComplete();
            }
        });
        //start asyncronous
        NuProcess p = b.start();
        System.out.println("Process started");
        emitter.setCancellable(() -> p.destroy(true));
    });
}

静态可观察过程（List cmd）{
返回可见。创建（发射器->{
NuProcessBuilder b=新的NuProcessBuilder（cmd）；
b、 setProcessListener（新的NuAbstractProcessHandler（）{
@凌驾
公共void onStdout（ByteBuffer缓冲区，布尔闭合）{
//进程线程上的调用
byte[]bytes=新字节[buffer.remaining（）]；
buffer.get（字节）；
发射器.onNext（字节）；
}
@凌驾
public void onExit（int statusCode）{
//进程线程上的调用
emitter.onComplete（）；
}
});
//异步启动
NUP进程=b.start（）；
System.out.println（“进程已启动”）；
发射器.setCancelable（（）->p.destroy（true））；
});
}

正如您所看到的，nu process events在它自己的线程中调用Asynchronous。基本上是成功的。但是如果我想运行多个串行进程呢？
在这种情况下，我的实现被破坏了，因为发射发生在另一个线程上。
在下面的代码中，所有进程同时启动：

public static void main(String[] args) throws InterruptedException {

    List<String> cmd = List.of("bash", "-c", "printf hello && sleep 1 && printf world");
    process(cmd).subscribeOn(Schedulers.single()).subscribe();
    process(cmd).subscribeOn(Schedulers.single()).subscribe();
    process(cmd).subscribeOn(Schedulers.single()).subscribe();
    process(cmd).subscribeOn(Schedulers.single()).subscribe();
    process(cmd).subscribeOn(Schedulers.single()).subscribe();
    process(cmd).subscribeOn(Schedulers.single()).subscribe();

    Thread.sleep(1000);
}

publicstaticvoidmain（String[]args）抛出InterruptedException{
List cmd=List.of（“bash”、“-c”、“printf hello&&sleep 1&&printf world”）；
process（cmd）.subscribeOn（Schedulers.single（））.subscribe（）；
process（cmd）.subscribeOn（Schedulers.single（））.subscribe（）；
process（cmd）.subscribeOn（Schedulers.single（））.subscribe（）；
process（cmd）.subscribeOn（Schedulers.single（））.subscribe（）；
process（cmd）.subscribeOn（Schedulers.single（））.subscribe（）；
process（cmd）.subscribeOn（Schedulers.single（））.subscribe（）；
睡眠（1000）；
}

如何使用“正确”线程实现Observable？
您可以使用
concatMap
实现：

Observable.range(1, 10).concatMap(integer -> process(cmd)).subscribe();

您可以使用
concatMap
：

Observable.range(1, 10).concatMap(integer -> process(cmd)).subscribe();

是的，但这是单链的工作。如果我想要全局限制进程并发性，例如
Schedulers.single（）？
您可以使用
Observable.range（1,10）.flatMap（integer->process（cmd），n）.subscribe（）其中
n
-进程数是的，但它是在单链上工作的。如果我想要全局限制进程并发性，例如
Schedulers.single（）？
您可以使用
Observable.range（1,10）.flatMap（integer->process（cmd），n）.subscribe（）其中
n
-进程数