[C++11 并发编程] 17 超时等待 - clock和duration

之前我们看到的所有等待机制都是不会超时的，也就是说，等待某个同步事件的线程会一直挂起。有些情况下，我们希望设置一个最长等待时间，使得程序可以继续与用户进行交互，使得用户可以取消这个操作。我们先来看看C++11提供的时钟类clock：

clock

clock提供了如下四种信息：

    当前时间 
    存放从clock获取到的时间的类型
    时钟每个tick的周期
    每个tick的周期是否固定，固定则为“steady”时钟

Member functions
now [static]   returns a std::chrono::time_point representing the current point in time
                      (public static member function)
to_time_t [static]   converts a system clock time point to std::time_t
                             (public static member function)
from_time_t  [static]  converts std::time_t to a system clock time point
                                  (public static member function)

下面是一个简单的实例，计算不同长度向量中元素的和并打印程序执行的时间：

 #include <iostream>
    #include <vector>
    #include <numeric>
    #include <chrono>
     
    volatile int sink;
    int main()
    {
        for (auto size = 1ull; size < 1000000000ull; size *= 100) {
            // record start time
            auto start = std::chrono::system_clock::now();
            // do some work
            std::vector<int> v(size, 42);
            sink = std::accumulate(v.begin(), v.end(), 0u); // make sure it's a side effect
            // record end time
            auto end = std::chrono::system_clock::now();
            std::chrono::duration<double> diff = end-start;
            std::cout << "Time to fill and iterate a vector of "
                      << size << " ints : " << diff.count() << " s\n";
        }
    }

程序执行结果如下：

Time to fill and iterate a vector of 1 ints : 2.93e-06 s
Time to fill and iterate a vector of 100 ints : 2.94e-06 s
Time to fill and iterate a vector of 10000 ints : 8.9962e-05 s
Time to fill and iterate a vector of 1000000 ints : 0.00859845 s
Time to fill and iterate a vector of 100000000 ints : 0.948915 s

时钟的tick周期可以通过std::ratio<x,y>来指定，

一秒tick25下的时钟周期为  std::ratio<1,25>

每2.5秒tick一下的时钟周期为 std::ratio<5,2>

tick周期稳定的时钟被称为稳定时钟，它的is_steady静态成员变量为true。对于非稳定时钟，在本地时钟发生漂移时，会自动进行调整，这就可能导致后执行的now()操作可能比先执行的now()操作得到的时间更小。在多线程环境下，超时操作需要使用稳定的时钟。可以使用std::chrono::steady_clock来获得稳定的时钟。

std::chrono::system_clock则被称为实时时钟，可以被转换为time_t值，也可以通过time_t转换为system_clock类型。

std::chrono::high_resolution_clock则提供了系统能支持的最高精度的时钟。
 duration

duration用于指定一个时间段，std::chrono::duration<>类模版的第一个参数指定周期的标示类型（比如int, long或者double），第二个参数指定周期的单位（一个单位代表多少秒）。

例如，以分钟为单位的周期定义如下，一分钟为60秒：

std::chrono::duration<short, std::ratio<60, 1>>

以毫秒为单位的周期定义如下，一秒钟为1000毫秒：

std::chrono::duration<double, std::ratio<1, 1000>>

此外，标准库在std::chrono名字空间还提供了一系列预定义的周期精度，例如：nanoseconds，microseconds，milliseconds，seconds，minutes和hours。这样如果要用精度为分秒的周期，可以使用如下代码：

std::duration<double, std::centi>;

下面一个例子中，定义了多种类型的duration，并在它们之间进行转换：

  

    #include <iostream>
    #include <chrono>
     
    int main()
    {
        using shakes = std::chrono::duration<int, std::ratio<1, 100000000>>;
        using jiffies = std::chrono::duration<int, std::centi>;
        using microfortnights = std::chrono::duration<float, std::ratio<12096,10000>>;
        using nanocenturies = std::chrono::duration<float, std::ratio<3155,1000>>;
     
        std::chrono::seconds sec(1);     
        std::cout << "1 second is:\n";
        std::cout << std::chrono::duration_cast<shakes>(sec).count()
                  << " shakes\n";
        std::cout << std::chrono::duration_cast<jiffies>(sec).count()
                  << " jiffies\n";
        std::cout << microfortnights(sec).count() << " microfortnights\n";
        std::cout << nanocenturies(sec).count() << " nanocenturies\n";
    }

程序执行效果如下：

1 second is:
100000000 shakes
100 jiffies
0.82672 microfortnights
0.316957 nanocenturies

基于duration，等待一个期望35毫秒的实现如下：

 std::future<int> f=std::async(some_task);
   
 if(f.wait_for(std::chrono::milliseconds(35))==std::future_status::ready)
     do_something_with(f.get());

等待函数会返回一个状态来标示是超时了还是等待的时间发生了。如例子所示，等待的是一个期望，如果超时了，返回值为std::future_status::timeout，如果时间发生了，返回值为std::future_status::ready。

基于duration的等待机制使用的是稳定时钟。