C++11锁机制mutex、lock_guard与unique_lock详细解析

#include <iostream>
#include <thread>
#include <mutex>
std::mutex mtx;  // 这就是我们的"门锁"
int shared_value = 0;  // 这是我们要保护的"卫生间"
void increment_value() {
    mtx.lock();  // 进去之前先锁门
    std::cout << "线程 " << std::this_thread::get_id() << " 进入临界区" << std::endl;
    // 想象这是个很复杂的操作，需要一些时间
    shared_value++;
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::cout << "线程 " << std::this_thread::get_id() << " 即将离开，共享值为: " << shared_value << std::endl;
    mtx.unlock();  // 用完了记得开锁，让别人能进来
}
int main() {
    std::thread t1(increment_value);
    std::thread t2(increment_value);
    t1.join();
    t2.join();
    return 0;
}

void safer_increment() {
    std::lock_guard<std::mutex> guard(mtx);  // 保安上岗，自动锁门
    std::cout << "线程 " << std::this_thread::get_id() << " 进入临界区" << std::endl;
    // 即使这里抛出异常，离开函数作用域时lock_guard也会自动解锁
    shared_value++;
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::cout << "线程 " << std::this_thread::get_id() << " 即将离开，共享值为: " << shared_value << std::endl;
    // 不需要手动解锁，guard离开作用域时会自动解锁
}

void flexible_operation() {
    std::unique_lock<std::mutex> superlock(mtx);  // 默认情况下构造时会锁定mutex
    std::cout << "线程 " << std::this_thread::get_id() << " 开始工作" << std::endl;
    shared_value++;
    // 假设这里不需要锁了，可以提前解锁
    superlock.unlock();
    std::cout << "临时解锁，执行一些不需要保护的操作" << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    // 需要再次访问共享资源时，可以重新上锁
    superlock.lock();
    shared_value++;
    std::cout << "线程 " << std::this_thread::get_id() << " 完成工作，共享值为: " << shared_value << std::endl;
    // 同样，不需要手动解锁，离开作用域时会自动解锁（如果当时处于锁定状态）
}

std::unique_lock<std::mutex> master_lock(mtx, std::defer_lock);  // 创建时不锁定
if (master_lock.try_lock()) {  // 尝试锁定，如果失败也不会阻塞
    std::cout << "成功获取锁！" << std::endl;
} else {
    std::cout << "获取锁失败，但我可以去做别的事" << std::endl;
}
// 还可以配合条件变量使用
std::condition_variable cv;
std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, []{ return ready; });  // 这里会自动解锁并等待条件满足

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
class ATMSystem {
private:
    double cash_available;  // ATM中可用现金
    bool maintenance_mode;  // 是否处于维护模式
    std::mutex mtx;
    std::condition_variable cv;  // 条件变量，用于等待维护结束
public:
    ATMSystem(double initial_cash) : cash_available(initial_cash), maintenance_mode(false) {}
    // 用户取款操作
    bool withdraw(double amount) {
        // 这里必须用unique_lock，因为条件变量wait需要它
        std::unique_lock<std::mutex> lock(mtx);
        // 如果ATM正在维护中，等待维护结束
        cv.wait(lock, [this] { return !maintenance_mode; });
        // 检查余额并取款
        if (cash_available >= amount) {
            std::this_thread::sleep_for(std::chrono::milliseconds(50));
            cash_available -= amount;
            std::cout << "取出: " << amount << "，ATM剩余现金: " << cash_available << std::endl;
            return true;
        }
        std::cout << "ATM现金不足，取款失败！当前剩余: " << cash_available << std::endl;
        return false;
    }
    // 开始系统维护
    void start_maintenance() {
        std::lock_guard<std::mutex> guard(mtx);
        maintenance_mode = true;
        std::cout << "ATM进入维护模式，暂停服务" << std::endl;
    }
    // 结束系统维护
    void end_maintenance() {
        {
            std::lock_guard<std::mutex> guard(mtx);
            maintenance_mode = false;
            std::cout << "ATM维护完成，恢复服务" << std::endl;
        }
        // 通知所有等待的取款线程
        cv.notify_all();
    }
    // 补充现金
    void refill_cash(double amount) {
        std::lock_guard<std::mutex> guard(mtx);
        cash_available += amount;
        std::cout << "ATM补充现金: " << amount << "，当前总现金: " << cash_available << std::endl;
    }
};
// 模拟用户线程
void user_thread(ATMSystem& atm, int user_id) {
    std::cout << "用户 " << user_id << " 尝试取款..." << std::endl;
    atm.withdraw(100);
}
// 模拟维护线程
void maintenance_thread(ATMSystem& atm) {
    std::this_thread::sleep_for(std::chrono::milliseconds(20));
    atm.start_maintenance();
    // 执行维护操作
    std::this_thread::sleep_for(std::chrono::milliseconds(300));
    atm.refill_cash(500);
    // 维护结束
    atm.end_maintenance();
}
int main() {
    ATMSystem atm(300);  // 初始现金300元
    // 启动一个维护线程和多个用户线程
    std::thread maint(maintenance_thread, std::ref(atm));
    std::vector<std::thread> users;
    for (int i = 1; i <= 5; ++i) {
        users.push_back(std::thread(user_thread, std::ref(atm), i));
    }
    // 等待所有线程结束
    maint.join();
    for (auto& t : users) {
        t.join();
    }
    return 0;
}