我正在使用.cpp源代码进行实时模拟。我必须每 0.2 秒（200 毫秒）采样一次……有一个 while 循环在每个时间步都采样一次……我想同步这个 while 循环的执行以每（200 毫秒）采样一次...我应该如何修改 while 循环？
while (1){
// get a sample every 200 ms
}
问问题
7738 次
5 回答
6
简单而准确的解决方案std::this_thread::sleep_until：
#include "date.h"
#include <chrono>
#include <iostream>
#include <thread>
int
main()
{
using namespace std::chrono;
using namespace date;
auto next = steady_clock::now();
auto prev = next - 200ms;
while (true)
{
// do stuff
auto now = steady_clock::now();
std::cout << round<milliseconds>(now - prev) << '\n';
prev = now;
// delay until time to iterate again
next += 200ms;
std::this_thread::sleep_until(next);
}
}
"date.h"延迟部分不需要。它在那里提供round<duration>功能（现在在 C++17 中），并使其更容易打印出durations. 这一切都在“做事”之下，与循环延迟无关。
只需得到一个chrono::time_point，添加你的延迟，然后睡到那个time_point。只要您的“东西”花费的时间少于您的延迟时间，您的循环将平均保持您的延迟。不需要其他线程。不需要计时器。只是<chrono>和sleep_until。
这个例子只是为我输出：
200ms
205ms
200ms
195ms
205ms
198ms
202ms
199ms
196ms
203ms
...
于 2017-03-29T14:50:58.477 回答
2
您的要求很棘手，除非您使用的是实时操作系统。
但是，Boost 有一个支持你想要的库。（但是，不能保证您每 200 毫秒就会被准确地调用一次。
Boost ASIO 库可能是您正在寻找的，这里是他们教程中的代码：
//
// timer.cpp
// ~~~~~~~~~
//
// Copyright (c) 2003-2012 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include <iostream>
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
int main()
{
boost::asio::io_service io;
boost::asio::deadline_timer t(io, boost::posix_time::seconds(5));
t.wait();
std::cout << "Hello, world!\n";
return 0;
}
链接在这里：boost asio的链接。
您可以使用此代码，然后像这样重新排列它
#include <iostream>
#include <boost/asio.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
int main()
{
boost::asio::io_service io;
while(1)
{
boost::asio::deadline_timer t(io, boost::posix_time::seconds(5));
// process your IO here - not sure how long your IO takes, so you may need to adjust your timer
t.wait();
}
return 0;
}
下一页还有一个异步处理 IO 的教程。
于 2013-02-18T21:00:51.220 回答
1
提供的答案向您表明，Boost 中有可用的工具来帮助您完成此任务。我的最新产品说明了如何使用setitimer()，这是用于迭代计时器的 POSIX 工具。
你基本上需要这样的改变：
while (1){
// wait until 200 ms boundary
// get a sample
}
使用迭代计时器，触发的信号将中断任何阻塞的信号调用。因此，您可以永远阻止某些事情。select会做得很好：
while (1){
int select_result = select(0, 0, 0, 0, 0);
assert(select_result < 0 && errno == EINTR);
// get a sample
}
要为每 200 毫秒建立一个间隔计时器，请使用setitimer(), 传入适当的间隔。在下面的代码中，我们将间隔设置为 200 毫秒，第一个间隔从现在开始 150 毫秒。
struct itimerval it = { { 0, 200000 }, { 0, 150000 } };
if (setitimer(ITIMER_REAL, &it, 0) != 0) {
perror("setitimer");
exit(EXIT_FAILURE);
}
现在，您只需要安装一个SIGALRM什么都不做的信号处理程序，代码就完成了。
您可以点击链接查看完整的示例。
如果在程序执行期间有可能触发多个信号，那么与其依赖被中断的系统调用，不如阻塞SIGALRM处理程序可以确定的方式唤醒的东西。一种可能性是将while循环块放在read管道的读取端。然后信号处理程序可以写入该管道的写入端。
void sigalarm_handler (int)
{
if (write(alarm_pipe[1], "", 1) != 1) {
char msg[] = "write: failed from sigalarm_handler\n";
write(2, msg, sizeof(msg)-1);
abort();
}
}
按照链接查看完整的示例。
于 2013-02-18T22:58:25.503 回答
1
#include <thread>
#include <chrono>
#include <iostream>
int main() {
std::thread timer_thread;
while (true) {
timer_thread = std::thread([](){
std::this_thread::sleep_for (std::chrono::seconds(1));
});
// do stuff
std::cout << "Hello World!" << std::endl;
// waits until thread has "slept"
timer_thread.join();
// will loop every second unless the stuff takes longer than that.
}
return 0;
}
于 2017-03-29T07:23:57.140 回答
0
要获得绝对的精确度几乎是不可能的——也许在嵌入式系统中。但是，如果您只需要一个近似的频率，则可以使用std::chrono(c++11) 或boost::chrono. 像这样：
while (1){
system_clock::time_point now = system_clock::now();
auto duration = now.time_since_epoch();
auto start_millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
//run sample
now = system_clock::now();
duration = now.time_since_epoch();
auto end_millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
auto sleep_for = max(0, 200 - (end_millis - start_millis ));
std::this_thread::sleep_for( sleep_for );
}
于 2013-02-18T21:10:20.190 回答