定义于头文件 

class mutex;            (C++11 起) 

mutex 类是能用于保护共享数据免受从多个线程同时访问的同步原语。

mutex 提供排他性非递归所有权语义：

• 调用方线程从它成功调用 lock 或 try_lock 开始，到它调用 unlock 为止占有 mutex 。
• 线程占有 mutex 时，所有其他线程若试图要求 mutex 的所有权，则将阻塞（对于 lock 的调用）或收到 false 返回值（对于 try_lock ）.
• 调用方线程在调用 lock 或 try_lock 前必须不占有 mutex 。

若 mutex 在仍为任何线程所占有时即被销毁，或在占有 mutex 时线程终止，则行为未定义。 mutex 类满足互斥体 (Mutex) 和标准布局类型 (StandardLayoutType) 的全部要求。

std::mutex 既不可复制亦不可移动。

构造互斥

mutex();            (1) (C++11 起) 
 
mutex( const mutex& ) = delete;    (2) (C++11 起) 

1) 构造互斥。调用后互斥在未锁定状态。

2) 复制构造函数被删除。

参数

（无）

异常

若构造不成功则抛出 std::system_error 。

解锁互斥

void unlock();        (C++11 起) 

解锁互斥。

互斥必须为当前执行线程所锁定，否则行为未定义。

此操作同步于（定义于 std::memory_order ）任何后继的取得同一互斥所有权的锁操作。

参数

（无）

返回值

（无）

异常

（无）

注意

通常不直接调用 unlock() ：用 std::unique_lock 与 std::lock_guard 管理排他性锁定。

锁定互斥，若互斥不可用则阻塞

void lock();            (C++11 起) 

锁定互斥。若另一线程已锁定互斥，则到 lock 的调用将阻塞执行，直至获得锁。

若 lock 为已占有 mutex 的线程调用，则行为未定义：例如，程序可能死锁。鼓励能检测非法使用的实现抛出以 resource_deadlock_would_occur 为错误条件的 std::system_error ，而不是死锁。

同一互斥上先前的 unlock() 操作同步于（定义于 std::memory_order ）此操作。

参数

（无）

返回值

（无）

异常

错误发生时抛出 std::system_error ，包括底层操作系统阻止 lock 满足其规定的错误。在抛出任何异常的情况下，不锁定互斥。

注意

通常不直接调用 lock() ：用 std::unique_lock 与 std::lock_guard 管理排他性锁定。

调用示例

#include 
#include 
#include 
#include 
 
int g_num = 0;  // 为 g_num_mutex 所保护
std::mutex g_num_mutex;
 
void slow_increment(int id) 
{
    for (int i = 0; i < 3; ++i) {
        g_num_mutex.lock();
        ++g_num;
        std::cout << id << " => " << g_num << '\n';
        g_num_mutex.unlock();
 
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}
 
int main()
{
    std::thread t1(slow_increment, 0);
    std::thread t2(slow_increment, 1);
    t1.join();
    t2.join();
}

可能的输出

尝试锁定互斥，若互斥不可用则返回

bool try_lock();            (C++11 起) 

尝试锁定互斥。立即返回。成功获得锁时返回 true ，否则返回 false 。

允许此函数虚假地失败而返回 false ，即使互斥当前未为任何其他线程所锁定。

若已占有 mutex 的线程调用 try_lock ，则行为未定义。

若此操作返回 true ，则同一互斥上的先前 unlock() 操作同步于（定义于 std::memory_order ）它。注意若此操作返回 false ，则先前的 lock() 不与之同步。

参数

（无）

返回值

若成功取得锁则为 true ，否则为 false 。

异常

（无）

调用示例

#include 
#include 
#include 
#include  // std::cout
 
std::chrono::milliseconds interval(100);
 
std::mutex smutex;
int job_shared = 0; // 两个线程都能修改 'job_shared',
// mutex 将保护此变量
 
int job_exclusive = 0; // 只有一个线程能修改 'job_exclusive'
// 不需要保护
 
// 此线程能修改 'job_shared' 和 'job_exclusive'
void job_1()
{
    std::this_thread::sleep_for(interval); // 令 'job_2' 持锁
 
    while (true)
    {
        // 尝试锁定 mutex 以修改 'job_shared'
        if (smutex.try_lock())
        {
            std::cout << "job shared (" << job_shared << ")\n";
            smutex.unlock();
            return;
        }
        else
        {
            // 不能获取锁以修改 'job_shared'
            // 但有其他工作可做
            ++job_exclusive;
            std::cout << "job exclusive (" << job_exclusive << ")\n";
            std::this_thread::sleep_for(interval);
        }
    }
}
 
// 此线程只能修改 'job_shared'
void job_2()
{
    smutex.lock();
    std::this_thread::sleep_for(5 * interval);
    ++job_shared;
    smutex.unlock();
}
 
int main() 
{
    std::thread thread_1(job_1);
    std::thread thread_2(job_2);
 
    thread_1.join();
    thread_2.join();
}

可能的输出