std::unique_lock什么

std::unique_lock是C++11标准库中的一个互斥锁封装类，它提供了一种灵活的方式来管理和控制互斥锁。与std::lock_guard不同的是，std::unique_lock允许锁的所有权在构造函数和析构函数之间转移，这意味着它可以在需要时锁定和解锁，还可以在不需要时释放锁。另外，std::unique_lock还提供了更多的控制选项，如延迟锁定、尝试锁定、递归锁定等，使其更加灵活和强大。

相关问题

std::unique_lock

std::unique_lock是C++标准库中的一个类，用于提供对互斥量的独占访问。它的构造函数相对于std::lock_guard更加灵活，可以接受额外的参数。std::unique_lock的构造函数有多个版本，其中一个默认构造函数的声明如下：unique_lock() noexcept; \[1\]

另外，std::unique_lock还提供了移动构造函数，可以将一个std::unique_lock对象移动到另一个对象中。例如，在下面的例子中，rtn_unique_lock函数返回一个std::unique_lock对象，然后在work1函数中使用移动构造函数将其移动到munique2对象中：\[2\]

std::unique_lock<std::mutex> rtn_unique_lock() {
    std::unique_lock<std::mutex> tmp(mlock);
    return tmp;
}

void work1(int& s) {
    for (int i = 1; i <= 5000; i++) {
        std::unique_lock<std::mutex> munique2 = rtn_unique_lock();
        s += i;
    }
}

此外，std::unique_lock还提供了一个成员函数owns_lock，用于判断当前std::unique_lock对象是否获得了锁。在下面的例子中，print_star函数使用std::unique_lock对象尝试对互斥量进行加锁，如果成功则打印'*'，否则打印'x'：\[3\]

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

std::mutex mtx; // 互斥量

void print_star() {
    std::unique_lock<std::mutex> lck(mtx, std::try_to_lock);
    if (lck)
        std::cout << '*';
    else
        std::cout << 'x';
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 500; ++i)
        threads.emplace_back(print_star);
    for (auto& x : threads)
        x.join();
    return 0;
}

综上所述，std::unique_lock是一个灵活的类，用于提供对互斥量的独占访问，并且具有多个构造函数和移动构造函数，以及一个owns_lock成员函数用于判断是否获得了锁。
#### 引用[.reference_title]
- *1* *3* [std::unique_lock 介绍](https://blog.csdn.net/u012372584/article/details/96852295)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item]
- *2* [C++多线程unique_lock详解](https://blog.csdn.net/Charles_Zaqdt/article/details/104180967)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item]
[ .reference_list ]

std::unique_lock<std::mutex> lock

std::unique_lock<std::mutex> lock 是在C++中使用std::unique_lock对std::mutex进行加锁的方法。它提供了比std::lock_guard更高级的功能。

以下是一个示例代码：

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mutex_;

void threadFunction()
{
    std::unique_lock<std::mutex> lock(mutex_);
    // 在这里执行需要保护的代码
    std::cout << "线程已获得锁" << std::endl;
    // ...
    std::cout << "线程释放锁" << std::endl;
}

int main()
{
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);

    t1.join();
    t2.join();

    return 0;
}

在上面的示例中，我们创建了两个线程t1和t2，并且它们都会执行threadFunction函数。在threadFunction函数中，我们使用std::unique_lock<std::mutex> lock(mutex_)来锁定互斥量mutex_，以确保同一时间只有一个线程能够访问被保护的代码。当一个线程获得锁时，其他线程将被阻塞，直到锁被释放。