public member function
<mutex>

std::mutex::try_lock

bool try_lock();
如果互斥量未被锁定,则锁定互斥量
尝试锁定 互斥量,不阻塞
  • 如果 互斥量 当前未被任何线程 *锁定*,则调用线程将其 *锁定*(从现在开始,直到其成员 unlock 被调用,该线程才 *拥有* 互斥量)。
  • 如果 互斥量 当前被另一个线程锁定,该函数将失败并返回 false,而不阻塞(调用线程继续执行)。
  • 如果 互斥量 当前被调用此函数的同一线程锁定,将导致 *死锁*(具有 *未定义行为*)。有关允许同一线程多次锁定的 *互斥量类型*,请参阅 recursive_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
// mutex::try_lock example
#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex

volatile int counter (0); // non-atomic counter
std::mutex mtx;           // locks access to counter

void attempt_10k_increases () {
  for (int i=0; i<10000; ++i) {
    if (mtx.try_lock()) {   // only increase if currently not locked:
      ++counter;
      mtx.unlock();
    }
  }
}

int main ()
{
  std::thread threads[10];
  // spawn 10 threads:
  for (int i=0; i<10; ++i)
    threads[i] = std::thread(attempt_10k_increases);

  for (auto& th : threads) th.join();
  std::cout << counter << " successful increases of the counter.\n";

  return 0;
}

可能的输出(可能为 1 到 100000 之间的任何计数)

80957 successful increases of the counter.


数据竞争

互斥量 对象作为 *原子操作* 被访问/修改(不会导致数据争用)。

异常安全

如果 互斥量 当前未被调用线程锁定,则此函数永远不会抛出异常(无抛出保证)。
否则,将导致未定义行为

另见