std::unique_lock<Mutex>:: try_lock

尝试非阻塞地锁定（即获取所有权）关联的互斥量。实际调用 mutex ( ) - > try_lock ( ) 。

当不存在关联互斥量或该互斥量已被此 std::unique_lock 锁定时，将抛出 std::system_error 异常。

参数

(无)

返回值

true 表示已成功获取互斥锁的所有权， false 表示获取失败。

异常

• 由 mutex ( ) - > try_lock ( ) 抛出的任何异常（ Mutex 类型在 try_lock 中不会抛出异常，但自定义的 Lockable 可能会）。

• 如果没有关联的互斥锁，将抛出 std::system_error ，其错误代码为 std::errc::operation_not_permitted 。

• 如果互斥锁已被此 std::unique_lock 锁定，将抛出 std::system_error ，错误代码为 std::errc::resource_deadlock_would_occur 。

示例

#include <chrono>
#include <iostream>
#include <mutex>
#include <thread>
#include <vector>
using namespace std::chrono_literals;
int main()
{
    std::mutex counter_mutex;
    std::vector<std::thread> threads;
    using Id = int;
    auto worker_task = [&](Id id, std::chrono::seconds wait, std::chrono::seconds acquire)
    {
        // 在获取锁之前等待几秒
        std::this_thread::sleep_for(wait);
        std::unique_lock<std::mutex> lock(counter_mutex, std::defer_lock);
        if (lock.try_lock())
            std::cout << '#' << id << ", lock acquired.\n";
        else
        {
            std::cout << '#' << id << ", failed acquiring lock.\n";
            return;
        }
        // 持锁一段时间
        std::this_thread::sleep_for(acquire);
        std::cout << '#' << id << ", releasing lock (via destructor).\n";
    };
    threads.emplace_back(worker_task, Id{0}, 0s, 2s);
    threads.emplace_back(worker_task, Id{1}, 1s, 0s);
    threads.emplace_back(worker_task, Id{2}, 3s, 0s);
    for (auto& thread : threads)
        thread.join();
}

#0, lock acquired.
#1, failed acquiring lock.
#0, releasing lock (via destructor).
#2, lock acquired.
#2, releasing lock (via destructor).

参见