chrono 概述

chrono 是一个头文件的名字，也是一个std namespace下的一个子namespace.
这个头文件里的几乎所有元素都是定义在 std::chrononamespace下。

这个头文件下的元素主要用来处理时间。主要通过以下3个概念的相关方法来实现：

Duration
表示时间跨度，比如：1分钟，2小时，10毫秒，等等。
是这个库中的 duration类模板实现的，由 count 和精确度组成(比如 10 milliseconds)
Time points
时间点。在这个库中，用 time_point类模板来表示自 epoch 以来的时间跨度。
epoch 是一个对所有使用相同clock的 time_point 对象都一样的一个固定的点。（注：比如 1970-01-01 00：00：00）
Clocks
是一个将 time point 对应到真实物理时间的一个框架。
此库提供了至少 3 种 clock：
system_clock, steady_clock, high_resolution_clock
这些clock有自己的方法来将当前时间表示成一个 time_point.

std::chrono::duration

template <class Rep, class Period = ratio<1> >
class duration;

在内部实现中，durantion object 将 count存储为 rep类型（即类模板的第一个参数），可以被成员函数 count()取出来。
count表示的是有多少个 periods, 每个 period 的大小由第二个模板参数表示(即 Period)。 Period 表示的是一秒的多少分之一。

下面是一些typedef：

chrono::hours
chrono::minutes
chrono::secodns
chrono::milliseconds: ratio<1, 1e3>
chrono::microseconds: ratio<1, 1e6>
chrono::nanoseconds: ratio<1, 1e9>

std::chrono::time_point

template <class Clock, class Duration=typename Clock::duration>
class time_point;

Three Clocks

std::chrono::high_resolution_clock

high_resolution_clock 是clock中使用最短的tick period的clock. 它可能是 system_clock 或 steady_clock 的同义词。

std::chrono::steady_clock

steady_clock就是专门被设计用来计算时间间隔的（time interval）。

std::chrono::system_clock

system_clock是一个系统范围的实时的clock.

三种 clock 的区别

steady_clock:
单调的时钟，相当于计时的秒表；只会增长，适合用于记录程序耗时，但不能提供日期等信息；

high_resolution_clock:
当前系统能够提供的最高精度的时钟；是不可以修改的。相当于 steady_clock 的高精度版本。

system_clock:
系统的时钟；因为系统的时钟可以修改，如NTP校时；所以用系统时间计算时间差可能不准，但可以提供日期等信息。

程序示例

统计程序执行时间

#include <iostream>
#include <chrono>
using namespace std;
using namespace std::chrono;


void time_cost_func()
{
    long sum = 0;
    
    for (long i=0; i<1e9; i++) {
        if (i%2) sum -= i;
        else sum += i*2;
    }
    cout << "sum = " << sum << endl;
}

int main()
{
    high_resolution_clock::time_point t1, t2;
    steady_clock::time_point t3, t4;
    system_clock::time_point t5, t6;
    
    duration<double> time_span;
    chrono::milliseconds ms;
    
    // Test high_resolution_clock 
    t1 = high_resolution_clock::now();
    time_cost_func();
    t2 = high_resolution_clock::now();
    
    time_span = duration_cast<duration<double>>(t2 - t1);
    ms = duration_cast<chrono::milliseconds>(t2 - t1); // or, change 't2 - t1' to 'time_span'
    
    cout << "Test high_resolution_clock: " << endl;
    cout << "This function took " << time_span.count() << " seconds." << endl;
    cout << "This function took " << ms.count() << " milliseconds." << endl;
    
    // Test steady_clock 
    t3 = steady_clock::now();
    time_cost_func();
    t4 = steady_clock::now();
    
    time_span = duration_cast<duration<double>>(t4 - t3);
    ms = duration_cast<chrono::milliseconds>(t4 - t3); 
    
    cout << "Test steady_clock: " << endl;
    cout << "This function took " << time_span.count() << " seconds." << endl;
    cout << "This function took " << ms.count() << " milliseconds." << endl;
    
    // Test system_clock 
    t5 = system_clock::now();
    time_cost_func();
    t6 = system_clock::now();
    
    time_span = duration_cast<duration<double>>(t6 - t5);
    ms = duration_cast<chrono::milliseconds>(t6 - t5);
    
    cout << "Test system_clock: " << endl;
    cout << "This function took " << time_span.count() << " seconds." << endl;
    cout << "This function took " << ms.count() << " milliseconds." << endl;
    
    return 0;
}

让当前线程 sleep 的代码

#include <iostream>
#include <chrono>
#include <thread>
using namespace std;

int main()
{
    int count = 3;
    cout << "Wait for " << count << " seconds please" << endl;
    
    for (int i=count; i>0; i--) {
        cout << i << endl;
        std::this_thread::sleep_for(chrono::seconds(1)); 
    }
    
    cout << "Boom!" << endl;
    return 0;
}

多线程程序的时间统计

再来一段多线程程序的时间统计。
这次用system_clock, 看起来最不精确的那个。

#include <iostream>
#include <vector>
#include <chrono>
#include <thread>
#include <string>
#include <sstream>
using namespace std;
using namespace chrono;


void time_cost_func(int id)
{
    stringstream ss; 
    system_clock::time_point t1 = system_clock::now();
    
    ss << "Start thread " << id << "\n";
    cout << ss.str();
    
    long sum = 0;
    
    for (long i=0; i<1e9; i++) {
        if (i%2) sum -= i;
        else sum += i*2;
    }
    
    system_clock::time_point t2 = system_clock::now();
    milliseconds ms = duration_cast<milliseconds>(t2-t1);
    
    ss.str("");
    ss << "Thread " << id << " took " << ms.count() << " milliseconds\n";
    cout << ss.str();
}

void run_threads()
{
    system_clock::time_point t1 = system_clock::now();
    
    vector<std::thread> vec_threads;
    
    for (int i=0; i<10; ++i) {
        std::thread  th(time_cost_func, i);
        vec_threads.push_back(std::move(th));
    }
    
    auto it = vec_threads.begin();
    for (; it != vec_threads.end(); ++it) {
        (*it).join();
    }
    
    system_clock::time_point t2 = system_clock::now();
    milliseconds ms = duration_cast<milliseconds>(t2-t1);
    cout << "Total time cost: " << ms.count() << " milliseconds" << endl;
}

int main()
{
    run_threads();
    
    return 0;
}

编译命令：

g++ 1.cpp -lpthread

注意，别加-O3.

运行结果如下：

$./a.out
Start thread 0
Start thread 1
Start thread 2
Start thread 3
Start thread 4
Start thread 5
Start thread 6
Start thread 7
Start thread 8
Start thread 9
Thread 1 took 2177 milliseconds
Thread 2 took 2178 milliseconds
Thread 4 took 2179 milliseconds
Thread 9 took 2183 milliseconds
Thread 7 took 2188 milliseconds
Thread 0 took 2191 milliseconds
Thread 6 took 2194 milliseconds
Thread 3 took 2197 milliseconds
Thread 8 took 2212 milliseconds
Thread 5 took 2215 milliseconds
Total time cost: 2215 milliseconds