# std::try_lock

< cpp‎ | thread

定义于头文件 `<mutex>` |  |
template< class Lockable1, class Lockable2, class... LockableN > int try_lock( Lockable1& lock1, Lockable2& lock2, LockableN&... lockn ); |  | (C++11 起)

尝试锁定每个给定的可锁定 (Lockable) 对象 `lock1`、 `lock2`、 `...`、 `lockn` ，通过以从头开始的顺序调用 `try_lock` 。

若调用 `try_lock` 失败，则不再进一步调用 `try_lock` ，并对任何已锁对象调用 `unlock` ，返回锁定失败对象的 `0` 底下标。

若调用 `try_lock` 抛出异常，则在重抛前对任何已锁对象调用 `unlock` 。

### 参数

lock1, lock2, ... , lockn | - | 要锁定的可锁定 (Lockable) 对象

### 返回值

成功时为 `-1` ，否则为锁定失败对象的 `0` 底下标值。

### 示例

下列示例用 `std::try_lock` 周期地记录并重置运行于分离线程的计数器。

    #include <mutex>
    #include <vector>
    #include <thread>
    #include <iostream>
    #include <functional>
    #include <chrono>

    int main()
    {
        int foo_count = 0;
        std::mutex foo_count_mutex;
        int bar_count = 0;
        std::mutex bar_count_mutex;
        int overall_count = 0;
        bool done = false;
        std::mutex done_mutex;

        auto increment = [](int &counter, std::mutex &m,  const char *desc) {
            for (int i = 0; i < 10; ++i) {
                std::unique_lock<std::mutex> lock(m);
                ++counter;
                std::cout << desc << ": " << counter << '\n';
                lock.unlock();
                std::this_thread::sleep_for(std::chrono::seconds(1));
            }
        };

        std::thread increment_foo(increment, std::ref(foo_count),
            std::ref(foo_count_mutex), "foo");
        std::thread increment_bar(increment, std::ref(bar_count),
            std::ref(bar_count_mutex), "bar");

        std::thread update_overall([&]() {
            done_mutex.lock();
            while (!done) {
                done_mutex.unlock();
                int result = std::try_lock(foo_count_mutex, bar_count_mutex);
                if (result == -1) {
                    overall_count += foo_count + bar_count;
                    foo_count = 0;
                    bar_count = 0;
                    std::cout << "overall: " << overall_count << '\n';
                    foo_count_mutex.unlock();
                    bar_count_mutex.unlock();
                }
                std::this_thread::sleep_for(std::chrono::seconds(2));
                done_mutex.lock();
            }
            done_mutex.unlock();
        });

        increment_foo.join();
        increment_bar.join();
        done_mutex.lock();
        done = true;
        done_mutex.unlock();
        update_overall.join();

        std::cout << "Done processing\n"
                  << "foo: " << foo_count << '\n'
                  << "bar: " << bar_count << '\n'
                  << "overall: " << overall_count << '\n';
    }

可能的输出：

    bar: 1
    foo: 1
    foo: 2
    bar: 2
    foo: 3
    overall: 5
    bar: 1
    foo: 1
    bar: 2
    foo: 2
    bar: 3
    overall: 10
    bar: 1
    foo: 1
    bar: 2
    foo: 2
    overall: 14
    bar: 1
    foo: 1
    bar: 2
    overall: 17
    foo: 1
    bar: 1
    foo: 2
    overall: 20
    Done processing
    foo: 0
    bar: 0
    overall: 20

### 参阅

lock (C++11) | 锁定指定的互斥体，若任何一个不可用则阻塞 (函数模板)