#include <mutex>
std::mutex mtx;
void wrong_func() {
    mtx.lock(); // 手動加鎖
    // 臨界區(qū)操作：修改共享資源
    int a = 10;
    // 忘記解鎖 → 死鎖！
    // 或如果臨界區(qū)拋出異常，unlock()永遠執(zhí)行不到 → 死鎖！
    // mtx.unlock(); 
}

#include <mutex>
std::mutex mtx;
void right_func() {
    // 創(chuàng)建lock_guard對象時，自動調用mtx.lock()
    std::lock_guard<std::mutex> lock(mtx);
    // 臨界區(qū)：安全操作共享資源
    int a = 10;
} // lock_guard對象出作用域，析構時自動調用mtx.unlock()
  // 即使臨界區(qū)拋出異常，析構函數(shù)也會執(zhí)行 → 必解鎖！

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);
        // 短臨界區(qū)：只保護必要的代碼
        shared_data = 100;
    } // 此處提前解鎖，不影響后續(xù)非臨界區(qū)代碼
    // 非臨界區(qū)：無需持鎖，提升并發(fā)效率
    sleep(1); 
}

void func_with_exception() {
    std::lock_guard<std::mutex> lock(mtx);
    // 臨界區(qū)拋出異常
    throw std::runtime_error("出錯了");
    // 無需手動unlock，析構函數(shù)會處理
}
int main() {
    try {
        func_with_exception();
    } catch (...) {
        // 捕獲異常后，鎖已經被釋放，其他線程可正常獲取
    }
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
std::mutex mtx;
int shared_count = 0; // 共享資源
// 線程函數(shù)：累加共享變量
void increment(int n) {
    for (int i = 0; i < n; ++i) {
        // lock_guard自動加鎖/解鎖
        std::lock_guard<std::mutex> lock(mtx);
        shared_count++;
        // 出循環(huán)迭代的作用域，自動解鎖
    }
}
int main() {
    std::vector<std::thread> threads;
    // 創(chuàng)建10個線程，每個線程累加1000次
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment, 1000);
    }
    // 等待所有線程結束
    for (auto& t : threads) {
        t.join();
    }
    // 正確輸出10000，無數(shù)據(jù)錯亂
    std::cout << "最終count值：" << shared_count << std::endl;
    return 0;
}