# std::timed_mutex::try_lock_for

< cpp‎ | thread‎ | timed mutex

template< class Rep, class Period > bool try_lock_for( const std::chrono::duration<Rep,Period>& timeout_duration ); |  | (C++11 起)

尝试锁互斥。阻塞直到经过指定的 `timeout_duration` 或得到锁，取决于何者先到来。成功获得锁时返回 true ， 否则返回 false 。

若 `timeout_duration` 小于或等于 `timeout_duration.zero()` ，则函数表现同 try_lock() 。

由于调度或资源争议延迟，此函数可能阻塞长于 `timeout_duration` 。

标准推荐用 `steady_clock` 度量时长。若实现用 `system_clock` 代替，则等待时间亦可能对时钟调整敏感。

同 try_lock() ，允许此函数虚假地失败并返回 false ，即使在 `timeout_duration` 中某点互斥不为任何线程所锁定。

若此操作返回 true ，则同一互斥上先前的 unlock() 调用同步于（定义于 std::memory_order ）它。

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

### 参数

timeout_duration | - | 要阻塞的最大时长

### 返回值

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

### 异常

执行期间时钟、时间点或时长可能抛出的异常（标准库提供的时钟、时间点和时长决不抛出）

### 示例

    #include <iostream>
    #include <mutex>
    #include <thread>
    #include <vector>
    #include <sstream>

    std::mutex cout_mutex; // 控制到 std::cout 的访问
    std::timed_mutex mutex;

    void job(int id)
    {
        using Ms = std::chrono::milliseconds;
        std::ostringstream stream;

        for (int i = 0; i < 3; ++i) {
            if (mutex.try_lock_for(Ms(100))) {
                stream << "success ";
                std::this_thread::sleep_for(Ms(100));
                mutex.unlock();
            } else {
                stream << "failed ";
            }
            std::this_thread::sleep_for(Ms(100));
        }

        std::lock_guard<std::mutex> lock(cout_mutex);
        std::cout << "[" << id << "] " << stream.str() << "\n";
    }

    int main()
    {
        std::vector<std::thread> threads;
        for (int i = 0; i < 4; ++i) {
            threads.emplace_back(job, i);
        }

        for (auto& i: threads) {
            i.join();
        }
    }

可能的输出：

    [0] failed failed failed
    [3] failed failed success
    [2] failed success failed
    [1] success failed success

### 参阅

lock | 锁定互斥，若互斥不可用则阻塞 (公开成员函数)
try_lock | 尝试锁定互斥，若互斥不可用则返回 (公开成员函数)
try_lock_until | 尝试锁定互斥，若直至抵达指定时间点互斥不可用则返回 (公开成员函数)
unlock | 解锁互斥 (公开成员函数)