public member function
<mutex>

std::timed_mutex::try_lock_until

template <class Clock, class Duration>  bool try_lock_until (const chrono::time_point<Clock,Duration>& abs_time);
尝试锁定直到时间点
尝试锁定 timed_mutex,最多阻塞直到 abs_time
  • 如果 timed_mutex 当前未被任何线程锁定,则调用线程锁定它(从此时开始,直到其成员 unlock 被调用,该线程拥有 timed_mutex)。
  • 如果 timed_mutex 当前被另一个线程锁定,则调用线程的执行将被阻塞,直到解锁或直到 abs_time(以先到者为准,同时,其他未锁定的线程继续执行)。
  • 如果 timed_mutex 当前被调用此函数的同一线程锁定,则会产生死锁(具有未定义行为)。请参阅 recursive_timed_mutex 以了解允许同一线程多次锁定的定时互斥类型

timed_mutex 的所有锁定解锁操作遵循单个总顺序,所有可见效果锁定操作与同一对象上的先前解锁操作之间进行同步。

参数

abs_time
线程停止阻塞并放弃锁定尝试的时间点。
time_point 是表示特定绝对时间的对象。

返回值

如果函数成功*锁定*该线程的 timed_mutex,则返回 true
否则返回 false

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// timed_mutex::try_lock_until example
#include <iostream>       // std::cout
#include <chrono>         // std::chrono::system_clock
#include <thread>         // std::thread
#include <mutex>          // std::timed_mutex
#include <ctime>          // std::time_t, std::tm, std::localtime, std::mktime

std::timed_mutex cinderella;

// gets time_point for next midnight:
std::chrono::time_point<std::chrono::system_clock> midnight() {
  using std::chrono::system_clock;
  std::time_t tt = system_clock::to_time_t (system_clock::now());
  struct std::tm * ptm = std::localtime(&tt);
  ++ptm->tm_mday; ptm->tm_hour=0; ptm->tm_min=0; ptm->tm_sec=0;
  return system_clock::from_time_t (mktime(ptm));
}

void carriage() {
  if (cinderella.try_lock_until(midnight())) {
    std::cout << "ride back home on carriage\n";
    cinderella.unlock();
  }
  else
    std::cout << "carriage reverts to pumpkin\n";
}

void ball() {
  cinderella.lock();
  std::cout << "at the ball...\n";
  cinderella.unlock();
}

int main ()
{
  std::thread th1 (ball);
  std::thread th2 (carriage);

  th1.join();
  th2.join();

  return 0;
}

可能的输出(行序可能相反,或回车符变成南瓜)
at the ball...
ride back home on carriage


数据竞争

timed_mutex 对象的访问/修改是*原子操作*(不会导致数据竞争)。

异常安全

如果 timed_mutex 当前被调用线程锁定,则会导致未定义行为
否则,它提供与时长对象上的操作相同的保证(对于 <chrono> 中的时钟所使用的类型,这是一种无抛出保证)。

另见