Java 如何锁定线程直到可观察到的线程完成

我正在测试一个场景，我想发送一个事件，并观察使用者何时完成处理以继续流，即当我触发事件时，我需要阻止该主线程，直到使用者处理结束，使用rxJava Observable，我没有成功锁定主线程以等待可观察的结果

我的制作人

@Service
public class Producer {

    private MessageChannel output;

    @Autowired
    private Consumer consumer;

    @Autowired
    public Producer(Processor processor) {
        this.output = processor.output();
    }

    public void send(String event) {

        System.out.println("SENDING EVENT...");

        output.send(MessageBuilder.withPayload(event).build());

        //Observable<Boolean> obs = consumer.execute();
        //obs.subscribe();

        //Blocking process
        BlockingObservable.from(consumer.execute()).subscribe();

        //Continue to flow
        System.out.println("EVENT PROCESSED...");

    }
}

@服务
公共级制作人{
专用信道输出；
@自动连线
私人消费者；
@自动连线
公共制作人（处理器）{
this.output=processor.output（）；
}
公共无效发送（字符串事件）{
System.out.println（“发送事件…”）；
send（MessageBuilder.withPayload（event.build（））；
//可观测obs=consumer.execute（）；
//obs.subscribe（）；
//阻塞过程
BlockingObservable.from（consumer.execute（））.subscribe（）；
//源源不断
System.out.println（“事件处理…”）；
}
}

我的消费者

@Service
public class Consumer {

    @StreamListener(target = Processor.INPUT)
    public void receiver(@Payload String event){

        System.out.println("EVENT RECEIVED, PROCESSING...");
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        execute();

    }

    public Observable<Boolean> execute() {
        return Observable.<Boolean>create(emitter -> {
            try {
                System.out.println("EVENT STILL PROCESSING...");
                emitter.onNext(Boolean.TRUE);
            } catch (Exception e) {
                emitter.onError(new RuntimeException("ERROR"));
            }
            emitter.onCompleted();
        });
    }
}

@服务
公共类消费者{
@StreamListener（目标=处理器.INPUT）
公共无效接收器（@Payload String事件）{
System.out.println（“接收事件，处理…”）；
试一试{
时间单位。秒。睡眠（10）；
}捕捉（中断异常e）{
//TODO自动生成的捕捉块
e、 printStackTrace（）；
}
执行（）；
}
公共可观察执行（）{
返回可见。创建（发射器->{
试一试{
System.out.println（“事件仍在处理…”）；
emitter.onNext（Boolean.TRUE）；
}捕获（例外e）{
onError（新的运行时异常（“错误”））；
}
emitter.onCompleted（）；
});
}
}

您可以使用

BlockingObservable.toFuture（consumer.execute（））.get（）

来阻止线程，而不是

BlockingObservable.from（consumer.execute（））.subscribe（）
您需要使用操作符toBlockig（等待consumer消费）+single来获取值

   @Test
    public void observableEvolveAndReturnToStringValue() {
        assertTrue(Observable.just(10)
                             .map(String::valueOf)
                             .toBlocking()
                             .single()
                             .equals("10"));
    }

你可以在这里看到更多的例子