C++ 线程互斥锁 lock_guard的基本用法

#include <mutex>
std::mutex mtx;
void wrong_func() {
    mtx.lock(); // 手动加锁
    // 临界区操作：修改共享资源
    int a = 10;
    // 忘记解锁 → 死锁！
    // 或如果临界区抛出异常，unlock()永远执行不到 → 死锁！
    // mtx.unlock(); 
}

#include <mutex>
std::mutex mtx;
void right_func() {
    // 创建lock_guard对象时，自动调用mtx.lock()
    std::lock_guard<std::mutex> lock(mtx);
    // 临界区：安全操作共享资源
    int a = 10;
} // lock_guard对象出作用域，析构时自动调用mtx.unlock()
  // 即使临界区抛出异常，析构函数也会执行 → 必解锁！

std::lock_guard<std::mutex> lock1(mtx);
// std::lock_guard<std::mutex> lock2 = lock1; // 编译错误：禁止拷贝
// std::lock_guard<std::mutex> lock3(std::move(lock1)); // 编译错误：禁止移动

void func() {
    {
        std::lock_guard<std::mutex> lock(mtx);
        // 短临界区：只保护必要的代码
        shared_data = 100;
    } // 此处提前解锁，不影响后续非临界区代码
    // 非临界区：无需持锁，提升并发效率
    sleep(1); 
}

void func_with_exception() {
    std::lock_guard<std::mutex> lock(mtx);
    // 临界区抛出异常
    throw std::runtime_error("出错了");
    // 无需手动unlock，析构函数会处理
}
int main() {
    try {
        func_with_exception();
    } catch (...) {
        // 捕获异常后，锁已经被释放，其他线程可正常获取
    }
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
std::mutex mtx;
int shared_count = 0; // 共享资源
// 线程函数：累加共享变量
void increment(int n) {
    for (int i = 0; i < n; ++i) {
        // lock_guard自动加锁/解锁
        std::lock_guard<std::mutex> lock(mtx);
        shared_count++;
        // 出循环迭代的作用域，自动解锁
    }
}
int main() {
    std::vector<std::thread> threads;
    // 创建10个线程，每个线程累加1000次
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment, 1000);
    }
    // 等待所有线程结束
    for (auto& t : threads) {
        t.join();
    }
    // 正确输出10000，无数据错乱
    std::cout << "最终count值：" << shared_count << std::endl;
    return 0;
}