Java 如何在队列中使用处理程序Postdelayed？

我有一个情况，我创建了一个按钮和一个类似这样的函数

...
public void BtnOnClick(View view) {

    displayMsg();
}

...

private void displayMsg(){
    handler.postDelayed(new Runnable() {
        @Override
        public void run() {
            Toast.makeText(this, "TestQueue", Toast.LENGTH_SHORT).show();

        }
    }, 3000);

}
...

如果我单击按钮一次，则延迟3秒后会出现祝酒词。 但是如果我快速点击按钮两次或更多次，那么所有的祝酒词都会在3秒钟后同时出现，每次祝酒之间没有3秒钟的延迟，这是不好的。我希望在每次祝酒之间有3秒的间隔/延迟，尽管同时单击

有什么解决办法吗

如果队列中有多个处理程序，则每个处理程序的延迟时间在前一个处理程序延迟时间结束后开始。

也许您可以使用：

也许你可以使用：

---

您可以对请求进行排队，以确保每隔一段时间显示祝酒词

ArrayList<Runnable> requests = new ArrayList<>;
bool inProgress = false;
private void displayMsg(){
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            Toast.makeText(this, "TestQueue", Toast.LENGTH_SHORT).show();
            inProgress = false;
            if (requests.size() > 0) {
                handler.postDelayed(requests.remove(0), 3000 + Toast.LENGTH_SHORT);
            }
        }
    }
    if (!inProgress) {
        inProgress = true;
        handler.postDelayed(runnable, 3000);
    } else {
        requests.add(runnable);
    }
}

ArrayList请求=新建ArrayList；
bool-inProgress=false；
私有void displayMsg（）{
Runnable Runnable=新的Runnable（）{
@凌驾
公开募捐{
Toast.makeText（这是“TestQueue”，Toast.LENGTH_SHORT）.show（）；
inProgress=假；
if（requests.size（）>0）{
handler.postDelayed（requests.remove（0），3000+Toast.LENGTH\u SHORT）；
}
}
}
如果（！inProgress）{
inProgress=true；
handler.postDelayed（可运行，3000）；
}否则{
请求。添加（可运行）；
}
}

您可以将请求排队，以确保每隔一段时间显示祝酒词

ArrayList<Runnable> requests = new ArrayList<>;
bool inProgress = false;
private void displayMsg(){
    Runnable runnable = new Runnable() {
        @Override
        public void run() {
            Toast.makeText(this, "TestQueue", Toast.LENGTH_SHORT).show();
            inProgress = false;
            if (requests.size() > 0) {
                handler.postDelayed(requests.remove(0), 3000 + Toast.LENGTH_SHORT);
            }
        }
    }
    if (!inProgress) {
        inProgress = true;
        handler.postDelayed(runnable, 3000);
    } else {
        requests.add(runnable);
    }
}

ArrayList请求=新建ArrayList；
bool-inProgress=false；
私有void displayMsg（）{
Runnable Runnable=新的Runnable（）{
@凌驾
公开募捐{
Toast.makeText（这是“TestQueue”，Toast.LENGTH_SHORT）.show（）；
inProgress=假；
if（requests.size（）>0）{
handler.postDelayed（requests.remove（0），3000+Toast.LENGTH\u SHORT）；
}
}
}
如果（！inProgress）{
inProgress=true；
handler.postDelayed（可运行，3000）；
}否则{
请求。添加（可运行）；
}
}

试试这个：

private final Handler handler = new Handler() {

    final int DELAY = 3000;
    final int DELAY_MSG = 1;
    final Queue<Runnable> pendingRunnables = new ArrayDeque<>();

    @Override
    public void dispatchMessage(Message msg) {
        if (msg.what == DELAY_MSG) {
            final Runnable r = pendingRunnables.poll();
            if (r != null) {
                r.run();
                sendEmptyMessageDelayed(DELAY_MSG, DELAY);
            }
        } else {
            pendingRunnables.add(msg.getCallback());
            if (!hasMessages(DELAY_MSG)) {
                sendEmptyMessage(DELAY_MSG);
            }
        }
    }
};

...

// post action
handler.post(new Runnable() {
    @Override
    public void run() {
        Toast.makeText(this, "TestQueue", Toast.LENGTH_SHORT).show();
    }
});

private final Handler=new Handler（）{
最终整数延迟=3000；
最终整数延迟_MSG=1；
最终队列pendingRunnables=new ArrayQueue（）；
@凌驾
公共无效调度消息（消息消息消息）{
如果（msg.what==DELAY\u msg）{
final Runnable r=pendingRunnables.poll（）；
如果（r！=null）{
r、 run（）；
SendEmptyMessageDelay（延迟消息，延迟）；
}
}否则{
添加（msg.getCallback（））；
如果（！hasMessages（延迟消息））{
sendEmptyMessage（延迟消息）；
}
}
}
};
...
//事后行动
handler.post（新的Runnable（）{
@凌驾
公开募捐{
Toast.makeText（这是“TestQueue”，Toast.LENGTH_SHORT）.show（）；
}
});

试试这个：

private final Handler handler = new Handler() {

    final int DELAY = 3000;
    final int DELAY_MSG = 1;
    final Queue<Runnable> pendingRunnables = new ArrayDeque<>();

    @Override
    public void dispatchMessage(Message msg) {
        if (msg.what == DELAY_MSG) {
            final Runnable r = pendingRunnables.poll();
            if (r != null) {
                r.run();
                sendEmptyMessageDelayed(DELAY_MSG, DELAY);
            }
        } else {
            pendingRunnables.add(msg.getCallback());
            if (!hasMessages(DELAY_MSG)) {
                sendEmptyMessage(DELAY_MSG);
            }
        }
    }
};

...

// post action
handler.post(new Runnable() {
    @Override
    public void run() {
        Toast.makeText(this, "TestQueue", Toast.LENGTH_SHORT).show();
    }
});

private final Handler=new Handler（）{
最终整数延迟=3000；
最终整数延迟_MSG=1；
最终队列pendingRunnables=new ArrayQueue（）；
@凌驾
公共无效调度消息（消息消息消息）{
如果（msg.what==DELAY\u msg）{
final Runnable r=pendingRunnables.poll（）；
如果（r！=null）{
r、 run（）；
SendEmptyMessageDelay（延迟消息，延迟）；
}
}否则{
添加（msg.getCallback（））；
如果（！hasMessages（延迟消息））{
sendEmptyMessage（延迟消息）；
}
}
}
};
...
//事后行动
handler.post（新的Runnable（）{
@凌驾
公开募捐{
Toast.makeText（这是“TestQueue”，Toast.LENGTH_SHORT）.show（）；
}
});

你的意图是什么？如果已经有新的toast，则不显示新的toast或将toast排队？toast仅用于测试目的，我将在这里使用一些其他代码。我只想让我的处理者排队等待你的意图是什么？如果已经有新的toast，则不显示新的toast或将toast排队？toast仅用于测试目的，我将在这里使用一些其他代码。我只是想让我的处理程序排队等待延迟让我试试这个。不工作所有的祝酒词都会一个接一个地出现。我不确定你是如何创建你的类的。您可以尝试更改为

static ArrayList requests=new ArrayList但要小心，因为如果您的活动被破坏并且您没有清理列表，这可能会导致小内存泄漏。不幸的是，没有任何变化，因为我从未向队列中添加内容，所以它不起作用。。。现在试试。让我试试这个。不工作。所有的祝酒词一个接一个地出现，没有延迟。我不确定你是如何创建你的类的。您可以尝试更改为
static ArrayList requests=new ArrayList但要小心，因为如果您的活动被破坏并且您没有清理列表，这可能会导致小内存泄漏。不幸的是，没有任何变化，因为我从未向队列中添加内容，所以它不起作用。。。现在试试。让我试试这个。不，它需要API级别24，我使用最小API 16。让我试试这个。不，它需要API级别24，我使用最小API 16。谢谢，我认为这是最好的解决方案。你能告诉我如何更改每次可运行的延迟时间吗？谢谢，我认为这是最好的解决方案。你能告诉我如何更改每次运行的延迟时间吗？