lock_guard<mutex> lock代码示例

下面是一个使用 `lock_guard` 的示例代码：

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

std::mutex mtx; // 全局互斥锁

void printNumbers(int n) {
    std::lock_guard<std::mutex> lock(mtx); // 声明一个锁保护区域
    for (int i = 1; i <= n; i++) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::thread t1(printNumbers, 5);
    std::thread t2(printNumbers, 10);
    t1.join();
    t2.join();
    return 0;
}

上面的代码定义了一个全局互斥锁 `mtx`，并在 `printNumbers` 函数中使用了 `lock_guard` 声明一个锁保护区域。在 `main` 函数中，我们创建了两个线程分别调用 `printNumbers` 函数，并在主线程中等待两个线程执行完毕后退出。当一个线程获得了锁之后，另一个线程会被阻塞等待锁的释放，从而保证了输出的正确性。

相关问题

std::lock_guard<std::mutex> lock(_mutex)

`std::lock_guard<std::mutex> lock(_mutex)` 是 C++11 引入的一种用于管理互斥锁（mutex）的机制，它通过RAII（资源获取即初始化）的方式简化了对互斥锁的管理。

以下是对这一语句的解释：

1. **std::lock_guard**: 这是C++标准库中的一个模板类，用于在作用域内自动管理互斥锁。当一个 `std::lock_guard` 对象被创建时，它会尝试获取传入的互斥锁；当该对象被销毁时（例如，离开其作用域），它会自动释放互斥锁。

2. **std::mutex**: 这是C++标准库中用于线程同步的互斥锁类。互斥锁用于保护共享数据，防止多个线程同时访问导致的数据竞争和不一致。

3. **_mutex**: 这是一个 `std::mutex` 类型的变量，表示需要被管理的互斥锁。

4. **lock(_mutex)**: 这里创建了一个 `std::lock_guard<std::mutex>` 对象，并将 `_mutex` 传递给它。这意味着 `_mutex` 被锁定，直到 `lock` 对象超出其作用域并被销毁为止。

使用 `std::lock_guard` 的好处在于，它可以确保即使在异常或提前返回的情况下，互斥锁也能被正确释放，从而避免死锁的发生。

示例代码如下：

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

std::mutex _mutex;

void safe_print(const std::string& message) {
    // 创建一个 std::lock_guard 对象，自动管理互斥锁
    std::lock_guard<std::mutex> lock(_mutex);
    // 此时 _mutex 已被锁定
    std::cout << message << std::endl;
    // 当 lock 对象超出作用域时，_mutex 会被自动解锁
}

int main() {
    std::thread t1(safe_print, "Hello from thread 1");
    std::thread t2(safe_print, "Hello from thread 2");

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

    return 0;
}

在这个例子中，两个线程会安全地打印消息，而不会因为并发访问而导致数据竞争。

std::lock_guard<std::mutex>

`std::lock_guard<std::mutex>`是C++中的一个RAII（资源获取即初始化）类，用于自动管理互斥锁的加锁和解锁操作。它在构造函数中获取互斥锁的所有权，并在析构函数中释放互斥锁的所有权。这样可以确保在任何情况下，即使发生异常，互斥锁也会被正确地释放。

下面是一个使用`std::lock_guard<std::mutex>`的示例：

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

std::mutex mtx;

void print_block(int n, char c){
    std::lock_guard<std::mutex> lock(mtx); // 使用std::lock_guard获取互斥锁的所有权
    for(int i=0; i<n; ++i){
        std::cout << c;
    }
    std::cout << '\n';
} 

int main(){
    std::thread th1(print_block, 500,'*');
    std::thread th2(print_block, 500,'$');
    th1.join();
    th2.join();
    return 0;
}

在上面的示例中，`std::lock_guard<std::mutex>`被用来保护`print_block`函数中的临界区代码，确保同时只有一个线程可以访问临界区。这样可以避免多个线程同时访问共享资源而导致的数据竞争问题。