c++线程锁

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

// 定义一个全局变量，多个线程将尝试同时访问它
int shared_variable = 0;

// 定义一个互斥锁，用于保护对共享资源的访问
std::mutex mtx;

void increment() {
    // 尝试锁定互斥锁
    mtx.lock();

    // 批量增加共享变量的值
    for (int i = 0; i < 1000; ++i) {
        ++shared_variable;
    }

    // 解锁互斥锁
    mtx.unlock();
}

void increment_with_lock_guard() {
    // 使用lock_guard自动管理互斥锁的锁定和解锁
    std::lock_guard<std::mutex> lock(mtx);

    // 批量增加共享变量的值
    for (int i = 0; i < 1000; ++i) {
        ++shared_variable;
    }
}

int main() {
    // 创建两个线程，它们将并发地执行increment函数
    std::thread t1(increment);
    std::thread t2(increment);

    // 等待两个线程完成
    t1.join();
    t2.join();

    // 输出最终的共享变量值
    std::cout << "Final value of shared_variable: " << shared_variable << std::endl;

    // 重置共享变量
    shared_variable = 0;

    // 创建两个线程，它们将并发地执行increment_with_lock_guard函数
    std::thread t3(increment_with_lock_guard);
    std::thread t4(increment_with_lock_guard);

    // 等待两个线程完成
    t3.join();
    t4.join();

    // 输出最终的共享变量值
    std::cout << "Final value of shared_variable with lock_guard: " << shared_variable << std::endl;

    return 0;
}

解释说明：

1. 互斥锁 (std::mutex):

   • std::mutex 是 C++ 标准库中提供的一个类，用于实现线程同步。它可以确保同一时刻只有一个线程能够访问被保护的代码段（临界区）。

2. 手动锁定和解锁:

   • 在 increment 函数中，使用 mtx.lock() 和 mtx.unlock() 手动锁定和解锁互斥锁。这种方式需要程序员小心管理，以避免忘记解锁导致死锁。

3. std::lock_guard:

   • std::lock_guard 是 C++ 提供的一个 RAII（Resource Acquisition Is Initialization）风格的类，它可以在进入作用域时自动锁定互斥锁，并在离开作用域时自动解锁。这种方式更安全，不容易出错。

4. 线程创建与等待:

   • 使用 std::thread 创建线程，并通过 join 方法等待线程结束，确保主线程不会在子线程未完成之前退出。

5. 共享变量:

   • shared_variable 是一个全局变量，多个线程会尝试同时对其进行修改。如果不加锁，可能会导致竞态条件（race condition），从而得到错误的结果。通过互斥锁可以有效避免这种情况。

6. 输出结果:

   • 最终输出 shared_variable 的值，验证线程是否正确同步并更新了共享变量。