C++

參考

<mutex>

mutex

public member function
<mutex>

std::mutex::lock

void lock();
Lock mutex
The calling thread locks the mutex, blocking if necessary

  • If the mutex isn't currently locked by any thread, the calling thread locks it (from this point, and until its member unlock is called, the thread owns the mutex).
  • If the mutex is currently locked by another thread, execution of the calling thread is blocked until unlocked by the other thread (other non-locked threads continue their execution).
  • If the mutex is currently locked by the same thread calling this function, it produces a deadlock (with undefined behavior). See recursive_mutex for a mutex type that allows multiple locks from the same thread.

All lock and unlock operations on the mutex follow a single total order, with all visible effects synchronized between the lock operations and previous unlock operations on the same object.

The non-member function lock allows to lock more than one mutex object simultaneously, avoiding the potential deadlocks that can happen when multiple threads lock/unlock individual mutex objects in different orders.

Note that the order in which different concurrent locks are scheduled to return is unspecified, and not necessarily related to the order in which they are locked (depending on the system and library implementation).

引數

無

返回值

無

示例

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
 
// mutex::lock/unlock
#include <iostream>       // std::cout
#include <thread>         // std::thread
#include <mutex>          // std::mutex

std::mutex mtx;           // mutex for critical section

void print_thread_id (int id) {
  // critical section (exclusive access to std::cout signaled by locking mtx):
  mtx.lock();
  std::cout << "thread #" << id << '\n';
  mtx.unlock();
}

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

  for (auto& th : threads) th.join();

  return 0;
}

可能的輸出（行的順序可能不同，但它們絕不會交錯）
thread #1
thread #2
thread #3
thread #4
thread #5
thread #6
thread #7
thread #8
thread #9
thread #10


資料競爭

The mutex object is modified as an atomic operation (causing no data races).

異常安全

Basic guarantee: if an exception is thrown by this member function, the mutex object is left in a valid state. Further, a lock is never acquired by the thread that made the throwing call.
If the mutex is already locked by the current thread, calling this function causes a deadlock (undefined behavior): on certain library implementations, this causes the function to fail.

如果呼叫失敗，將丟擲system_error 異常
exception typeerror condition描述
system_errorerrc::resource_deadlock_would_occurA deadlock was detected (implementations may detect certain cases of deadlock).
system_errorerrc::operation_not_permittedThe thread does not have privileges to perform the operation.
system_errorerrc::device_or_resource_busyThe native handle type manipulated is already locked.
根據庫實現的不同，此成員函式還可能丟擲異常來報告其他情況。

另見

mutex::try_lock
如果未鎖定，則鎖定互斥量 (public member function)
mutex::unlock
解鎖互斥量 (public member function)