# std::mutex::try_lock

< cpp‎ | thread‎ | mutex

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

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

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

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

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

### 参数

（无）

### 返回值

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

### 异常

不抛出。

### 示例

    #include <chrono>
    #include <mutex>
    #include <thread>
    #include <iostream> // std::cout

    std::chrono::milliseconds interval(100);

    std::mutex mutex;
    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 (mutex.try_lock()) {
                std::cout << "job shared (" << job_shared << ")\n";
                mutex.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()
    {
        mutex.lock();
        std::this_thread::sleep_for(5 * interval);
        ++job_shared;
        mutex.unlock();
    }

    int main()
    {
        std::thread thread_1(job_1);
        std::thread thread_2(job_2);

        thread_1.join();
        thread_2.join();
    }

可能的输出：

    job exclusive (1)
    job exclusive (2)
    job exclusive (3)
    job exclusive (4)
    job shared (1)

### 参阅

lock | 锁定互斥，若互斥不可用则阻塞 (公开成员函数)
unlock | 解锁互斥 (公开成员函数)