延迟方法调用

Question

我有以下代码：

public void onEnter() {
   Observable<GObject> obs = context.update(activeG);
   obs.subscribe((gObj) -> {
        //TODO: add delay of 3 sec.
        activeG.publishNewG();
        activeG.nextState(GType.RUNNING);
    });
}

我的问题是，我怎么能把 3 秒的延迟放得这么

activeG.publishNewG()

被调用，然后

延迟 3 秒，然后调用

activeGame.nextState(GameStateType.RUNNING);

"发布新G"返回无效。

谢谢！

Answer 1

如果我

理解正确，您希望在publishNewG和nextState之间放置3秒的延迟。您可以使用doOnNext在序列中的某些点注入活动，例如，在 3 秒延迟之前和之后：

Observable.just(1)
.doOnNext(e -> System.out.println("Action before"))
.delay(3, TimeUnit.SECONDS)
.doOnNext(e -> System.out.println("Action after"))
.toBlocking().first();

Answer 2

您通常使用某种调度程序来完成此操作。Java有ScheduledExecutorService为你做这件事。

public class MyClass {
    private final ScheduledExecutorService scheduler;
    public MyClass() {
        scheduler = Executors.newSingleThreadScheduledExecutor();
    }
    public void onEnter() {
        Observable<GObject> obs = context.update(activeG);
        obs.subscribe((gObj) -> {
            activeG.publishNewG();
            // Run in 3 seconds
            scheduler.schedule(() -> {
                activeG.nextState(GType.RUNNING);
            }, 3, TimeUnit.SECONDS);
        });
    }
}

编辑：根据我对RxJava文档的理解，这就是你如何使用delay：

public void onEnter() {
    Observable<GObject> obs = context.update(activeG);
    // Observable that delays all events by 3 seconds
    Observable<GObject> delayed = obs.delay(3, TimeUnit.SECONDS);
    // This will fire immediately when an event happens
    obs.subscribe((gObj) -> {
        activeG.publishNewG();
    });
    // This will fire 3 seconds after an event happens
    delayed.subscribe((gObj) ->  {
        activeG.nextState(GType.RUNNING);
    });
}

Answer 3

您可以使用

timer 运算符轻松添加延迟。

例如：

    // simulated stream of events spread apart by 400ms
    Observable<Long> yourObservable = Observable.interval(400, TimeUnit.MILLISECONDS).take(3);
    yourObservable.flatMap(data -> {
        // add delay of 3 seconds
        return Observable.timer(3, TimeUnit.SECONDS).map(i -> data);
    }).map(dataAfterDelay -> {
        // do whatever you want after 3 seconds
        System.out.println("got data " + dataAfterDelay + " after 3 seconds");
        return dataAfterDelay + " processed after delay";
    }).toBlocking().forEach(System.out::println); // toBlocking here just as example to block main thread

Answer 4

可以使用

AFAIK Thread.sleep(3000)

如果没有，应该做这样的事情：

long start = new Date().getTime();
while(new Date().getTime() - start < 3000L){}