C++11 std::chrono时间库

参考：
https://blog.csdn.net/oncealong/article/details/28599655
https://blog.csdn.net/WizardtoH/article/details/81738682

std::chrono 概念

chrono是一个模版库，包含了一系列时间相关功能。可以很容易的实现定时功能。
chrono库主要包含了三种类型：时间间隔 Duration、时钟 Clocks 和时间点 Time Point。

Duration（时间间隔）

duration表示一段时间间隔，用来记录时间长度，可以表示几秒钟、几分钟或者几个小时的时间间隔，duration的原型是：

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

第一个参数 Rep 表示一种数值类型，用来表示 Period 的数量，比如int、float。
第二个模板参数是一个默认模板参数std::ratio，它的原型是：

template<std::intmax_t Num, std::intmax_t Denom = 1>
class ratio;

它表示每个时钟周期的秒数，其中第一个模板参数 Num 代表分子，Denom 代表分母，分母默认为 1，ratio 代表的是一个分子除以分母的分数值，比如 ratio<2> 代表一个时钟周期是两秒，ratio<60> 代表了一分钟，ratio<60*60> 代表一个小时，ratio<60*60*24> 代表一天。而 ratio<1, 1000> 代表的则是 1/1000 秒即一毫秒，ratio<1, 1000000> 代表一微秒，ratio<1, 1000000000> 代表一纳秒。
标准库为了方便使用，就定义了一些常用的时间间隔，如时、分、秒、毫秒、微秒和纳秒，在 chrono 命名空间下，它们的定义如下：

typedef duration <Rep, ratio<3600,1>> hours;
typedef duration <Rep, ratio<60,1>> minutes;
typedef duration <Rep, ratio<1,1>> seconds;
typedef duration <Rep, ratio<1,1000>> milliseconds;
typedef duration <Rep, ratio<1,1000000>> microseconds;
typedef duration <Rep, ratio<1,1000000000>> nanoseconds;

通过定义这些常用的时间间隔类型，我们能方便的使用它们，比如线程的休眠：

std::this_thread::sleep_for(std::chrono::seconds(3)); //休眠三秒
std::this_thread::sleep_for(std::chrono:: milliseconds (100)); //休眠100毫秒

另外，C++11 还提供了 duration 之间的类型转换 duration_cast，用于不同时间精度间的转换：

#include <iostream>
#include <chrono>

int main()
{
    std::chrono::seconds scd(10);
    std::cout << scd.count() << std::endl;                                                        // 10
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(scd).count() << std::endl; // 10000

    return 0;
}


// 精度高转换成精度低的时候会导致精度丢失，需要注意
#include <iostream>
#include <chrono>

int main()
{
    std::chrono::milliseconds scd(10001);
    std::cout << scd.count() << std::endl;                                                   // 10001
    std::cout << std::chrono::duration_cast<std::chrono::seconds>(scd).count() << std::endl; // 10

    return 0;
}

Time Point（时间点）

std::chrono::time_point 用于表示一个时间点，需要为时间点指定参考时钟 clock（clock 类需要满足指定要求，详见 https://zh.cppreference.com/w/cpp/named_req/Clock）和相对于参考时钟步进值。它被实现成如同存储一个 Duration 类型的自 Clock 的纪元起始开始的时间间隔的值。

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

time_point 表示一个时间点，用来获取 1970.1.1 以来的秒数和当前的时间, 可以做一些时间的比较和算术运算，可以和 ctime 库结合起来显示时间。
time_point 必须要 clock 来计时，time_point 有一个函数 time_from_eproch() 用来获得 1970 年 1 月 1 日到 time_point 时间经过的 duration。
下面的例子计算当前时间距离1970年1月一日有多少天：

#include <iostream>
#include <ratio>
#include <chrono>
int main()
{
    typedef std::chrono::duration<int, std::ratio<60 * 60 * 24>> days_type;
	//now 表示当前时间到格林威治标准时间的天数
    std::chrono::time_point<std::chrono::system_clock, days_type> today = std::chrono::time_point_cast<days_type>(std::chrono::system_clock::now());
    //std::chrono::system_clock::time_point等效于time_point<std::chrono::system_clock>
    std::cout << today.time_since_epoch().count() << " days since epoch" << std::endl;
    return 0;
}

其中 system_clock 是 C++11 实现的 clock 类（一般是从格林威治标准时间开始），此处作为 time_point 模板的第一个类型，第二个类型 Clock::duration 被定义为 days_type（天数），也就是说 time_point 表示从格林威治标准时间（1970-01-01 00:00:00.000）开始到指定时间的天数。
time_point 对象常用于 std::this_thread::sleep_until、std::timed_mutex::try_lock_until 等函数，作为入参：

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

int main()
{
    system_clock::time_point until = system_clock::now();
    until += seconds(5);
    std::this_thread::sleep_until(until); // 一直等待到当前时间加上5s之后的时间点

    return 0;
}

同样，time_point 也支持精度装换 time_point_cast：

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

int main()
{
    time_point<system_clock> now = system_clock::now();
    std::cout << now.time_since_epoch().count() << std::endl; // 毫秒级

    time_point<system_clock, hours> hour_now =
        time_point_cast<hours>(system_clock::now());
    std::cout << hour_now.time_since_epoch().count() << std::endl; // 小时级

    return 0;
}

Clocks（时钟）

C++11新增了时钟的概念，时钟 (Clock) 概念描述由 std::chrono::duration 、 std::chrono::time_point 和获取当前 time_point 的函数 now() 组成的一束内容，将时钟的 time_point 原点定为时钟的纪元。
可以通过 now() 来获取当前时间点：

#include <iostream>
#include <chrono>
int main()
{
    std::chrono::steady_clock::time_point t1 = std::chrono::system_clock::now();
    std::cout << "Hello World\n";
    std::chrono::steady_clock::time_point t2 = std::chrono::system_clock::now();
    std::cout << (t2 - t1).count() << "tick count" << endl;
    return 0;
}

通过时钟获取两个时间点之相差多少个时钟周期，我们可以通过 duration_cast 将其转换为其它时钟周期的 duration：

cout << std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1).count() << "microseconds" << endl;

Clocks包含三种时钟：
• system_clock
表示本地系统的时钟，因此是不稳定的，因为有可能被修改。上文已经举例了一些它的用法，下面再列举一个常用的显示当前系统时间的用法：
system_clock 的 to_time_t 方法可以将一个 time_point 转换为 ctime，而 from_time_t 方法则是相反的，它将 ctime 转换为 time_point：

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

int main()
{
    time_point<system_clock> now = system_clock::now();
    time_t t_now = system_clock::to_time_t(now);
    tm *tm_now = std::localtime(&t_now);
    std::cout << std::put_time(tm_now, "%Y-%m-%d %H:%M:%S") << std::endl;

    return 0;
}

• steady_clock
表示稳定的时间间隔，后一次调用 now() 得到的时间总是比前一次的值大（如果中途修改了系统时间，也不影响 now() 的结果），所以通常用来计算时间间隔：

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

int main()
{
    time_point<steady_clock> begin_time = steady_clock::now();
    std::this_thread::sleep_for(milliseconds(10));
    time_point<steady_clock> end_time = steady_clock::now();

    // steady_clock的精度为纳秒，装换成毫秒输出
    std::cout << duration_cast<milliseconds>(end_time - begin_time).count() << std::endl;

    getchar();
    return 0;
}

• high_resolution_clock
表示实现提供的拥有最小计次周期的时钟，它可以是system_clock或steady_clock的别名，或第三个独立时钟。在我的实验的机器中被定义为：

typedef steady_clock high_resolution_clock;

可以利用 high_resolution_clock 来实现一个类似于 boost.timer 的定时器，这样的 timer 在测试性能时会经常用到，经常用它来测试函数耗时，可实现毫秒微秒级定时，它的基本用法是这样的：

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

class Timer
{
public:
    Timer() : m_begin(high_resolution_clock::now()) {}
    void reset() { m_begin = high_resolution_clock::now(); }
    //默认输出毫秒
    int64_t elapsed() const
    {
        return duration_cast<chrono::milliseconds>(high_resolution_clock::now() - m_begin).count();
    }
    //微秒
    int64_t elapsed_micro() const
    {
        return duration_cast<chrono::microseconds>(high_resolution_clock::now() - m_begin).count();
    }
    //纳秒
    int64_t elapsed_nano() const
    {
        return duration_cast<chrono::nanoseconds>(high_resolution_clock::now() - m_begin).count();
    }
    //秒
    int64_t elapsed_seconds() const
    {
        return duration_cast<chrono::seconds>(high_resolution_clock::now() - m_begin).count();
    }
    //分
    int64_t elapsed_minutes() const
    {
        return duration_cast<chrono::minutes>(high_resolution_clock::now() - m_begin).count();
    }
    //时
    int64_t elapsed_hours() const
    {
        return duration_cast<chrono::hours>(high_resolution_clock::now() - m_begin).count();
    }

private:
    time_point<high_resolution_clock> m_begin;
};

void fun()
{
    cout << "hello word" << endl;
}

int main()
{
    Timer t; //开始计时
    fun();
    cout << t.elapsed() << endl;         //打印fun函数耗时多少毫秒
    cout << t.elapsed_micro() << endl;   //打印微秒
    cout << t.elapsed_nano() << endl;    //打印纳秒
    cout << t.elapsed_seconds() << endl; //打印秒
    cout << t.elapsed_minutes() << endl; //打印分钟
    cout << t.elapsed_hours() << endl;   //打印小时
}