1 概述

  定时互斥是一种时间可锁定的对象，它设计用于在代码的关键部分需要独占访问时发出信号，就像常规互斥一样，但还支持定时尝试锁定请求。
  因此，timed_mutex有两个额外的成员：try_lock_for和try_lock_until。
它保证是一个标准布局类。 标准布局类型是一种具有简单线性数据结构和访问控制的类型，可以很容易地用于与用其他编程语言（如C）编写的代码进行通信.
其类图如下:

2 使用实例

struct TimedFunction
{
   
    volatile int counter = 0;
    void fireworks(std::timed_mutex & muxtex)
    {
   
        while(!muxtex.try_lock_for(std::chrono::milliseconds(200)))
            ;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
        ++counter;
        muxtex.unlock();
    }

    void waitUtil(std::timed_mutex & muxtex, int seconds)
    {
   
        std::chrono::time_point<std::chrono::system_clock> timePoint 
            = std::chrono::system_clock::now() + std::chrono::seconds(seconds);
        std::cerr << "\n\nWait util " << seconds << " seconds... \n";
        if(muxtex.try_lock_until(timePoint))
        {
   
            muxtex.unlock();
            counter = 10;
        }
        else
            counter = 5;
    }
    void sleepFor(std::timed_mutex & muxtex, int seconds)
    {
   
        muxtex.lock();
        std::cerr << "\n\nSleep " << seconds << " seconds... \n";
        std::this_thread::sleep_for(std::chrono::seconds(seconds));
        muxtex.unlock();
    }
};

void TimedMutexSuite::try_lock_for()
{
   
    std::timed_mutex muxtex;
    TimedFunction function;
    std::thread threads[10];
    for(int i = 0; i < 10; i++)
        threads[i] = std::thread(&TimedFunction::fireworks, std::ref(function), std::ref(muxtex));
    for(auto &thread : threads)
        thread.join();
    TEST_ASSERT_EQUALS(true, function.counter