停止循环直到方法调用 onFinished()

Question

如何停止 for 循环并等到方法完成并在调用后继续 onFinish()？

我能想到的一个解决方案是使用 listeners 并在方法调用 onFinish() 时调用它，但我不知道如何停止循环并等待 listener . wait() 等函数也不起作用，因为 doCountDown() 可能比 wait()

花费更多或更少

for (int i = 0; i < 1; i++) {
    doCountDown();
    //Pause and wait for doCountDown() to finish
}

private void doCountDown(){

        new Handler(Looper.getMainLooper()).post(new Runnable() {
            @Override
            public void run() {
                new CountDownTimer(30000,100) {
                    @Override
                    public void onTick(long millisUntilFinished) {
                        //Do some stuff
                    }

                    @Override
                    public void onFinish() {
                        //Continue loop
                    }
                }.start();
            }
        });
}

Answer 1

您可以使用 CyclicBarrier。它是可重复使用的，因此您不必每次都创建它。

// this will create barrier for 2 parties.
CyclicBarrier barrier = new CyclicBarrier(2);
for (int i = 0; i < count; i++) {
    doCountDown();
    //Pause and wait for doCountDown() to finish
    // add try catch around for interrup exception
       barrier.await();
}
.......
@Override
public void onFinish() {
     ////Continue loop
      barrier.await();
}

Answer 2

它正在使用 Object.wait 和 Object.notify 方法。

// Whatever object
Object obj = new Object();

        for (int i = 0; i < 1; i++) {
            doCountDown(obj);
            // Pause and wait for doCountDown() to finish
            synchronized (obj) {
                try {
                    obj.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    private void doCountDown(Object obj) {

        new Handler(Looper.getMainLooper()).post(new Runnable() {
            @Override
            public void run() {
                new CountDownTimer(30000, 100) {
                    @Override
                    public void onTick(long millisUntilFinished) {
                        // Do some stuff
                    }

                    @Override
                    public void onFinish() {
                        // Continue loop
                        synchronized (obj) {
                            obj.notify();
                        }
                    }
                }.start();
            }
        });
    }

Answer 3

你也可以使用递归来得到你需要的结果。

doAnotherLine(0);

private void doAnotherLine(int i){
    //Some stopper method.. for example something like this
    if(i < list.size -1) doCountDown(i);

}

private void doCountDown(final int i){

        new Handler(Looper.getMainLooper()).post(new Runnable() {
            @Override
            public void run() {
                new CountDownTimer(30000,100) {
                    @Override
                    public void onTick(long millisUntilFinished) {
                        //Do some stuff
                    }

                    @Override
                    public void onFinish() {
                        doAnotherLine(i+1);
                    }
                }.start();
            }
        });
}

Answer 4

这里是对您关于只实施 1 个计时器的评论的回答：

private void doCountDowns(int count){

    new Handler(Looper.getMainLooper()).post(new Runnable() {
        @Override
        public void run() {
            int timer = 0; // if each timer does something else
            int ticks = 0;
            new CountDownTimer(30000 * count,100) {
                @Override
                public void onTick(long millisUntilFinished) {
                    //Do some stuff
                    if ((ticks++) == 3000) {
                        ticks = 0;
                        timer++;
                    }
                }

                @Override
                public void onFinish() {
                    // called only once, when everything is done
                }
            }.start();
        }
    });
}

doCountDowns(10) 将启动一个 10x 30000ms 的计时器，即滴答 3000x（每 100ms）。它可以解决你的问题吗？如果您的每个计时器都有另一项任务（但似乎并非如此），您可以引入 ticks 和 timer 字段来计算滴答计数和计时器。

也许您可以尝试解释一下，为什么您需要 10 个定时器每个滴答 30.000 毫秒而不是 1 个定时器滴答 300.000 毫秒。

停止循环直到方法调用 onFinished()

Stopping for loop until method calls onFinished()

java

loops

for-loop

countdowntimer