时钟和steady_clock测量的时间差
在C++中，std::chrono库提供了多种时钟类型，其中system_clock和steady_clock是最常用的两种。它们的主要区别在于测量时间的准确性和单调性。
system_clock
system_clock是一个系统级的实时时钟，它表示当前的系统时间，这个时间是可以被系统用户或管理员修改的。因此，system_clock不保证时间的单调性，也就是说，它可能会因为系统时间的调整而“倒退”。
steady_clock
steady_clock则是一个单调时钟，它从某个固定的时间点开始，保证时间只会向前推进，不会倒退。这种时钟非常适合用来测量时间间隔，因为它不受系统时间调整的影响。
时间差测量
由于system_clock可能会因为系统时间的调整而改变，所以直接比较system_clock和steady_clock测量的时间点是没有意义的。如果你想要测量两个时间点之间的时间差，应该使用同一种时钟类型来进行测量。
总的来说，steady_clock和system_clock各有其用途，选择哪种时钟类型取决于你的具体需求。
相关·内容
我使用的是运行在ARM上的代码(不是Intel处理器)。运行c++11代码示例(代码A)从：测试wait_for()机制。这是不正确的-看起来wait_for()不等待。在英特尔工作得很好。经过一些研究和使用，直接使用线程库和设置MONOTONIC_CLOCK定义，解决了这个问题(代码B)。(在ARM上运行不是问题)
我的问题是:如何强制C++11 API wait_for()使用MONOTONIC_CLOCK？
实际上，我想继续使用‘代码A’，但是使用MONOTONIC_CLOCK的支持或设置。谢谢
代码A
// condition_variable::wait_for example
#i
浏览 2提问于2019-01-23得票数 5
我有一个令人惊讶的观察，steady_clock在测量持续时间时给出的分辨率很差。我在cygwin下为windows编译。这是悲哀，是真的，还是我做错了什么？
auto start = std::chrono::steady_clock::now();
/*...*/
auto end = std::chrono::steady_clock::now();
std::cout << std::chrono::duration_cast<std::chrono::microseconds>
浏览 1提问于2015-04-10得票数 3
我的应用程序需要绝对时间戳(即包括日期和小时)，误差小于0.5s。服务器通过NTP进行同步，但我仍然希望检测服务器时钟是否由于某种原因而不能很好地同步。 我的想法是使用稳定时钟来验证系统时钟。我假设在一段时间内，比方说，1小时的稳定时钟应该与实际时间偏差很小(远低于0.5s)。我定期比较用稳定时钟和系统时钟测量的时间。如果两者之间的差异增大或跳跃很大，则可能表明NTP正在调整系统时钟，这可能意味着某些时间值不正确。 这是一个示例代码： #include <iostream>
#include <chrono>
#include <thread>
int
浏览 27提问于2020-01-17得票数 0
回答已采纳
1回答
我的应用服务器代码中有一行代码，它使用steady_clock获得时间戳值，如下所示：
uint64_t now = duration_cast<milliseconds>(steady_clock::now().time_since_epoch()).count();
现在我们有两个系统，machineA运行Ubuntu 12 (gcc 4.6.3 compiler)，machineB运行Ubuntu 14 (gcc 4.8.2 compiler)。
现在，我们在上编译应用服务器代码，在另一个 Ubuntu 12 VM (which has 4.7.3 compiler)上使用m
浏览 2提问于2015-08-19得票数 8
回答已采纳
我正在做一个项目，因为我需要检查两次之间的时间差，我得到了毫秒的时间差，但现在我想要微秒和纳秒的时间差来获得准确的时间差
我的代码：
QDateTime oStartTime = QDateTime::currentDateTime();
// some operetions //the difference is in micro and nano seconds differ
QDateTime oEndTime = QDateTime::currentDateTime();
quint64 elapsed = oStartTime.daysTo(oEn
浏览 29提问于2017-02-07得票数 0
假设我需要在多个线程中运行大量的计算(以及基准CPU时间)。作为一个玩具例子：
#include <chrono>
#include <future>
#include <iostream>
#include <vector>
using unit_t = std::chrono::nanoseconds;
unit_t::rep expensive_computation() {
auto start = std::chrono::steady_clock::now();
// Something time-consumi
浏览 0提问于2018-08-26得票数 2
回答已采纳
下面是简单的程序(数组排序)：
#include <stdio.h>
#include <conio.h>
#include <array>
#include <algorithm>
#include <chrono>
typedef unsigned int myInt;
static void shellSort(myInt arr[], const myInt length) {
if (length < 2) {
return;
}
myInt i, j, step;
浏览 4提问于2015-12-07得票数 1
回答已采纳
1回答
我有一些代码，用来测量c++中的时间差。在一段时间后，保存在一个浮点型变量中，我想启动一些东西。有没有办法将持续时间转换为浮点数或与浮点值进行比较？
下面是一些代码：
float maxDiff = 5;
auto start = std::chrono::high_resolution_clock::now();
//do something
auto finish = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> elapsed = finish - start;
if(elap
浏览 2提问于2018-03-20得票数 1
我有一个文件，头时间作为std::chrono::steady_clock参数。不同的服务器将它们写在磁盘上。在使用文件时，我将比较它们以找到最新的时间。我和混在一起
更新：
Q:，比较是否提供给我最新的文件？
问：，我应该用system_clock而不是steady_clock吗？
浏览 4提问于2020-10-15得票数 2
回答已采纳
我有一个包含std::chrono::system_clock::time_point的结构
struct NetInfo {
std::chrono::system_clock::time_point time;
std::chrono::steady_clock::time_point start;
};
当我试图将其中一个time_point分配给std::chrono::system_clock::now()的结果时
api::NetInfo ni;
ni.start = std::chrono::system_clock::now();
我得到了这个巨
浏览 2提问于2018-02-05得票数 3
回答已采纳
2回答
我需要一个可以用来计算间隔的单调时钟。要求：
必须是单调的，不能受设备时间的影响。
不能在应用程序会话期间重置。(会话中所有返回值的时间相同)
必须表示真实的秒(而不是cpu秒)，不能受当时运行的线程/进程数的影响。
秒分辨率就足够了。
在我的研究中，我找到了候选人：
std::clock()(ctime) -似乎使用cpu秒
boost::chrono::steady_clock() -它使用cpu秒吗？在应用程序session(launch-end)期间，时代会发生变化吗？
平台特定方法(clock_gettime、mach_absolute_time)
浏览 0提问于2014-02-27得票数 4
回答已采纳
std::system_clock和std::steady_clock有什么区别？(举例说明不同的结果/行为将是很好的)。
如果我的目标是精确地测量函数的执行时间(就像基准)，那么在std::system_clock、std::steady_clock和std::high_resolution_clock之间最好的选择是什么？
浏览 6提问于2012-11-07得票数 110
回答已采纳
我想知道使用steady_clock类(在C++ std库中)来进行游戏计时是否是个好主意。相对于使用游戏库的计时机制，使用它的利弊是什么？
浏览 0提问于2012-11-24得票数 7
回答已采纳
如何准确测量两台Linux机器之间的时间差？我听说“平”给RTT与操作系统的影响有关联，所以在纳秒级不准确？如果是这样的话，还需要测量Linux系统或Raspi中两台机器之间的时间差(偏移)吗？
浏览 0提问于2017-09-04得票数 2
我基本上有一个学校项目，测试不同的排序算法所需的时间，并记录它们用n个数排序所需的时间。所以我决定使用Boost库和c++来记录时间。在这一点上，我不确定该怎么做，我已经在谷歌上搜索过了，并发现人们使用不同的方法。例如：
auto start = boost::chrono::high_resolution_clock::now();
auto end = boost::chrono::high_resolution_clock::now();
auto time = (end-start).count();
或
boost::chrono::system_clock::now();
或
bo
浏览 1提问于2015-10-29得票数 3
我曾经用CLOCK_THREAD_CPUTIME_ID和clock_gettime测量不同线程的时间消耗。
但是clock_gettime是POSIX世界中的一个标准，所以当涉及到跨平台时，它不会在其他平台上工作，比如Windows。
我检查了C++ STD，直到现在发现了steady_clock，system_clcok，high_resolution_clock，这些都不能计时一个特定的线程。
我错过了什么吗？如果是，子弹是什么？或者如果没有，有什么建议吗？
浏览 8提问于2016-04-14得票数 3
回答已采纳
多年来，我一直对帧计时器使用下列时钟定义：
using frame_clock = std::conditional_t<
std::chrono::high_resolution_clock::is_steady,
std::chrono::high_resolution_clock,
std::chrono::steady_clock>;
换句话说，我想要一个使用最高分辨率定义的时钟，但它必须单调递增。注意，MSVC当前使用以下别名来定义std::chrono::high_resolution_clock
usin
浏览 2提问于2021-04-23得票数 3
回答已采纳
2回答
C++ -使用计时库执行0次
、、、、
我正在使用合并排序对一个数组进行排序。我使用Chrono库来测量时间，但有时结果是0。
int main() {
srand(50000);
int A[N];
for (int i = 0; i < N; i++) {
A[i] = rand();
}
cout << "Array non ordinato\n";
Stampa(A, N);
auto start = std::chrono::system_clock::now();
QuickSort(A, 0, N - 1
浏览 0提问于2019-12-10得票数 1
我需要找到执行一段代码所需的时间，并且该方法应该独立于系统时间(计时)，而且所有这些都不能工作。
我的用法有点像这样。
int main{
//start
function();
//end
time_take = end - start;
}
我在一个嵌入式平台上工作，在启动时没有合适的时间。在我的例子中，Fun广子的开始发生在ntp服务器设置实际时间之前，结束发生在获得确切的时间之后。所以，任何比较两点时差的方法都是行不通的。而且，CPU滴答号的数量对我来说是行不通的，因为我的程序在整个过程中都会很活跃地运行。
我尝试了传统的方法，但它们对我没有用。
浏览 19提问于2022-11-08得票数 0
请参阅下面的Qn内容：
正如上面已经讨论过的，我打算从1970年开始获得microseconds时间。
现在，在流行的平台上使用chrono::high_resolution_clock::now().time_since_epoch()很好，但OSX除外&可能是iOS。在我们的Mac系统中，系统重新启动后产生微秒时间，而不是从1970年开始。
是否有任何便携或Mac特定的方式来获得1970年以来的时间，具有microseconds的精度？
还欢迎针对Qt的解决方案。
浏览 2提问于2017-08-26得票数 2
回答已采纳
3回答
我试着给我的算法计时，但时间总是以零的形式出现。这是我的代码：
steady_clock::time_point start = steady_clock::now();
ReverseArray(list1, 1000000);
steady_clock::time_point end = steady_clock::now();
auto totalTime = end - start;
cout << duration_cast<microseconds>(totalTime).count()<< "\n";
浏览 5提问于2014-04-14得票数 0
回答已采纳
2回答
考虑以下代码：
#include <iostream>
#include <string>
#include <chrono>
using namespace std;
int main()
{
int iter = 1000000;
int loops = 10;
while (loops)
{
int a=0, b=0, c=0, f = 0, m = 0, q = 0;
auto begin = chrono::high_resolution_clock::now();
浏览 6提问于2016-03-02得票数 0
让我们使用下面的代码来度量使用20‘s调用的std::this_thread::sleep_for的持续时间：
#include <iostream>
#include <chrono>
#include <thread>
using namespace std;
using namespace std::chrono;
int main()
{
for (int i = 0; i < 20; i++)
{
auto start = steady_clock::now();
this_thread::
浏览 20提问于2016-03-02得票数 9
回答已采纳
2回答
提及
为什么下面的代码产生零作为输出？
int main()
{
steady_clock::time_point t1 = steady_clock::now();
//std::this_thread::sleep_for(std::chrono::milliseconds(1500));
steady_clock::time_point t2 = steady_clock::now();
auto timeC = t1.time_since_epoch().count();
auto timeD = t2.time_since_epoch().co
浏览 14提问于2015-07-20得票数 2
回答已采纳
我想对我产生的数据流进行时间标记，我想对其使用std::chrono::steady_clock。
这些时间戳与数据一起存储(作为uint64值数组？)，稍后我将需要再次处理这些时间戳。
现在，到目前为止，我还没有使用std::chrono库，所以我确实需要一些关于这个库的语法和最佳实践的帮助。
我可以使用以下方法获取和存储值：
uint64_t timestamp = std::chrono::steady_clock::now().time_since_epoch().count();
但我该怎么做呢？
在读取数据时，从uint64创建一个时点？
获取steady_cloc
浏览 0提问于2020-09-15得票数 0
回答已采纳
我制作了一个宏来调用std::chrono::high_resolution_clock::now()，VS一直说每当我调用它时都会出错，但它仍然可以工作。代码如下： #include <iostream>
#include <chrono>
using namespace std;
#define DIM 30
#define TEMPO_ATTUALE chrono::high_resolution_clock::now() 下面是我尝试调用宏时弹出的错误： class "std::chrono::steady_clock" has no me
浏览 36提问于2021-04-12得票数 0
3回答
什么是正确的方法来精确测量一个时间持续时间的围棋？大多数应用程序只使用标准的时间包和以下方法：
var startTime = time.Now()
doSomeHardWork()
var duration = time.Since(startTime) // or: time.Now() - startTime
但是，time.Now()返回当前的系统时间，这导致两个缺陷：
如果在测量期间更改了系统时间(例如，由于时区更改 (DST)或闰秒)，则由此产生的持续时间也是错误的。
系统时间可以比实时时间更快或更慢。这通常发生在操作系统将内部时钟与NTP时间服务器同步时(这种情况可能每小
浏览 8提问于2017-08-21得票数 34
回答已采纳
3回答
我刚刚注意到<chrono.h>中的以下代码，这对我来说没有任何意义。
struct system_clock
{
static const bool is_monotonic = false; // retained
static const bool is_steady = false;
};
class steady_clock
: public system_clock
{ // wraps monotonic clock
public:
static const bool is_monotonic = true; // re
浏览 1提问于2012-07-15得票数 16
回答已采纳
2回答
时机与“仿佛是”的规则
、、、、
总体上有一个很好的，但我不知道在测量时间时是否有例外。
考虑这一点(摘自，稍作修改)：
using std::chrono;
auto begin = steady_clock::now();
auto result = some_lengthy_calculation(some_params);
auto end = std::chrono::steady_clock::now();
std::cout << "Time diff = " << duration_cast<microseconds>(end - begin).coun
浏览 2提问于2017-10-04得票数 4
回答已采纳
我正在尝试编写一段代码，它将对由于同步而引起的系统时间变化做出反应。下面是在goroutine内部运行的非常简单的代码：
var start, end time.Time
var start_ts, end_ts int64
var diff_ts time.Duration
var diff time.Duration
for {
start = time.Now()
start_ts = start.Unix()
fmt.Printf("Now: => %v (%d);\n", start, start_ts)
time.Sleep(
浏览 2提问于2020-02-26得票数 0
回答已采纳
1回答
我正在寻找解决方案，这将给我最准确的睡眠一个函数的小值。我尝试了下面的代码来测试它：
#include <thread>
#include <chrono>
#include <functional>
#include <windows.h>
using ms = std::chrono::milliseconds;
using us = std::chrono::microseconds;
using ns = std::chrono::nanoseconds;
const int total_test = 100;
const int sl
浏览 15提问于2022-10-05得票数 1
回答已采纳
如NTP rfc中所定义的
“NTP算法的目标是最小化UTC和系统时钟之间的时间差和频率差异。”
我可以理解‘时间差’，但是什么是‘频差’，NTP试图同步？
浏览 7提问于2010-08-19得票数 3
回答已采纳
包含4种成员类型：rep、period、duration和timepoint。
chrono::steady_clock::duration是一个chrono::duration<rep,period>。chrono::steady_clock::period是一个ratio。
chrono::steady_clock::duration和chrono::steady_clock::period的类型是如何确定的？
例如,
chrono::steady_clock::duration可以为chrono::duration<int,period>，其中period为rat
浏览 0提问于2015-10-20得票数 6
3回答
就我对资源管理的了解而言，在堆上分配一些东西(操作符new)总是比在堆栈上分配(自动存储)慢，因为堆栈是基于LIFO的结构，因此它需要最少的簿记，下一个地址的指针是微不足道的。
到现在为止还好。现在看下面的代码：
/* ...includes... */
using std::cout;
using std::cin;
using std::endl;
int bar() { return 42; }
int main()
{
auto s1 = std::chrono::steady_clock::now();
std::packaged_task<int()&g
浏览 3提问于2015-07-24得票数 19
回答已采纳
所有5分的10个问题都需要在时间内回答。因此，应该显示每个问题n剩余时间所消耗的时间。有人能帮上忙吗？
浏览 0提问于2011-08-14得票数 1
我正在尝试使用稳定时钟来对我的代码部分进行基准测试，我在这里做了一些尝试。似乎有时它返回2次之间的差值，而有时它只是返回0。
我有以下代码。这不是我的程序中的真实代码，但说明了问题
typedef std::chrono::steady_clock::time_point clock_point;
for ( int i = 0; i < 2; i++ ) {
clock_point start_overall = std::chrono::steady_clock::now();
for ( int j = 0; j < 10000000; j++ ) {
浏览 1提问于2020-07-20得票数 1
我在我的项目中使用了一些time_point<steady_clock>变量，以便在特定的时间间隔内进行操作。我想在文件中序列化/反序列化这些值。
但是，来自time_since_epoch的steady_clock似乎不可靠，尽管system_clock的time_since_epoch很好，但它总是计算1970/1/1 (UNIX时间)的时间。
对我来说最好的解决方案是什么？似乎我必须以某种方式将steady_clock转换为system_clock，但我不认为这是可以实现的。
我已经读过这里的主题：
浏览 7提问于2021-06-03得票数 0
回答已采纳
使用boost::chrono::steady_clock或std::chrono::steady_clock是为了保证物理时间始终是单调的，并且不受系统中日期时间更改的影响。这是我的问题，如果我有两个进程需要不受系统日期时间更改的影响，仅交换time_since_epoch就足够了吗？换句话说，两个过程的时间解释到同一时期以来会是一样的吗？具体来说，我需要回答Windows和QNX的这个问题。
编辑:这两个进程运行在同一台计算机、相同的操作系统上，并通过IPC调用进行通信。
浏览 4提问于2015-06-17得票数 3
我使用TickCount()来确定事件之间的时间差或运行某段代码所需的时间。但在OSX10.8中，它是。因此，我需要一个相同的替代方案。
浏览 0提问于2012-11-22得票数 1
回答已采纳
1回答
我一直在读这篇文章，而数字加起来就不一样了。在我的操作系统(Windows)上，我可以像这样检查系统时钟的分辨率：
LARGE_INTEGER largeInt; // Basically a struct/union containing a long long
QueryPerformanceFrequency(&largeInt);
// largeInt now holds the frequency of my system's clock, it's 3903987
// This ends up being a resolution of about 25
浏览 5提问于2017-10-04得票数 0
我们使用了boost:chrono来实现定时器。下面是我们的实现：
boost::chrono::time_point<boost::chrono::steady_clock> untilTime(boost::chrono::steady_clock::now() + boost::chrono::milliseconds(dueTime));
boost::condition_variable m_condition;
(void)m_condition.wait_until(guard, untilTime);
在Ubuntu Linux 64位( 12.04和15.04
浏览 1提问于2015-08-21得票数 1
我想根据程序运行的时间创建带有时间戳的文件名，即
logfile_2020-04-21_18:11:10.txt
logfile_2020-04-22_18:13:43.txt
...
我可以得到时间戳
std::chrono::steady_clock::time_point timestamp = std::chrono::steady_clock::now();
但我不知道如何把它转换成字符串，更不用说人类可读的字符串了。
时间戳的确切格式并不重要，只要它有完整的日期和时间。是否有一种简单的方法在C++中使用标准库来实现这一点？
浏览 4提问于2020-05-06得票数 2
回答已采纳
基本上：
auto p1 = std::steady_clock::now().time_since_epoch().count();
... // do smth for unspecified period of time
auto p2 = std::steady_clock::now().time_since_epoch().count();
assert(p2 >= p1); // is this guaranteed?
如果是的话--这是怎么保证的？通过确保没有一个C++程序比std::steady_clock::duration::max() - std::st
浏览 1提问于2020-10-07得票数 5
回答已采纳
我试图通过查看数据的时间戳来查看我的数据是否有120秒的历史，因此我有以下代码：
uint64_t now = duration_cast<milliseconds>(steady_clock::now().time_since_epoch()).count();
bool is_old = (120 * 1000 < (now - data_holder->getTimestamp()));
在上面的代码中，data_holder->getTimestamp()是uint64_t，它以毫秒为单位返回时间戳。
现在，当我打印出now变量值时，我看到了这个10011
浏览 10提问于2015-07-22得票数 52
回答已采纳
为什么委员会将monotonic_clock改名为steady_clock？供应商正在为向后兼容性提供monotonic_clock，因此我预计monotonic_clock会持续一段时间。
在C++0x中放弃某些东西似乎有点早。编辑:提交者有权利和责任在发布之前尽可能地重命名组件，就像在本例中所做的那样。
我看不出改名有什么好处。
浏览 0提问于2011-07-21得票数 14
回答已采纳
1回答
在我们大学的一个项目中，我们正在做一个基准项目。我们本质上所做的就是产生一个随机的不。然后将其插入std::set (RBTree)中，然后删除它。我们在一个特定的时间间隔内这样做。本质上，这就是代码的样子。
auto randomNo = std::random_device{}();
//Measure insertion
auto start = std::chrono::steady_clock::now();
myset.insert(randomNo ); //log(n)
auto end = std::chrono::steady_clock::now();
auto dif
浏览 2提问于2021-03-04得票数 0
回答已采纳
3回答
我正在读取调用方法之前的系统时间，并在方法返回后立即读取时间差，这将给出方法执行所需的时间。
代码片段
long start = System.currentTimeMillis ();
method ();
long end = System.currentTimeMillis ();
System.out.println ("Time taken for execution is " + (end - start));
奇怪的是输出是0..how这有可能吗？
浏览 4提问于2011-12-17得票数 1
回答已采纳
1回答
我需要创建一个计时器，它将周期性地调用我的函数(例如，每50 my )。但问题是，在计时器运行时，我需要更改系统时间。我想使用boost来实现这一点，以便代码是可移植的。否则，我将在Linux机器上运行它。
我尝试过的事情：
尝试使用while循环和线程：：loop。使用steady_clock计算睡眠时间。
也尝试过使用deadline_timer
当系统时间被调整时，这两种方法都停止工作。
问:有没有任何方法(最好使用boost )来创建一个独立于系统时间的回调定时器？(样本代码的奖励业力)
浏览 2提问于2014-07-04得票数 2
回答已采纳
我在一台8核的Windows PC上运行了以下程序。函数(" function ")的运行时间非常短(几百微秒)。然而，线程3所需的运行时间通常是线程1的1.5倍，对此如何解释？
using namespace std::chrono;
double FUNCTION(){
double result=0.0;
for(int i=0; i<20'000; i++){
result=result+sqrt(i);
}
return result;
}
int main()
{
浏览 0提问于2020-12-28得票数 0
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
