C++常用的工具锁

前言

在 C++ 中，为了实现多线程环境下的同步，常用的锁主要包括以下几种：

一、std::mutex

std::mutex mtx;
mtx.lock();   // 加锁
// 访问共享资源
mtx.unlock(); // 解锁

 标准的互斥锁，用于保护共享资源，防止多个线程同时访问造成数据竞争。

二、std::timed_mutex

std::timed_mutex tmtx;
if (tmtx.try_lock_for(std::chrono::milliseconds(100))) {
    // 成功获取锁
    tmtx.unlock();
} else {
    // 未能获取锁
}

 一个支持超时的互斥锁，可以在指定时间内尝试获取锁，如果在给定时间内没有获取到锁，则放弃锁的请求。

三、std::recursive_mutex

std::recursive_mutex rec_mtx;
void recursive_function() {
    rec_mtx.lock();
    // 执行一些操作
    rec_mtx.unlock();
}

 递归互斥锁，允许同一个线程多次获取同一把锁，而不会导致死锁。

四、std::lock_guard

std::mutex mtx;
void safe_function() {
    std::lock_guard<std::mutex> guard(mtx);
    // 在 guard 的生命周期内，锁是持有的
    // guard 结束时自动解锁
}

RAII（资源获取即初始化）风格的锁，帮助自动管理锁的生命周期，防止忘记解锁。

五、std::unique_lock

std::mutex mtx;
void flexible_function() {
    std::unique_lock<std::mutex> lock(mtx);
    // 在需要时锁定
    lock.lock();
    // 可以提前解锁
    lock.unlock();
}

 与 std::lock_guard 类似，但提供了更灵活的锁定和解锁操作（可以延迟锁定、提前解锁、重新锁定等）

六、锁的使用

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

int counter = 0;           // 共享资源
std::mutex mtx;            // 只定义一把锁

void increment() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 加锁保护
        ++counter;                             // 访问共享资源
    }
}

void decrement() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(mtx); // 加锁保护
        --counter;                             // 访问共享资源
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(decrement);

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

    std::cout << "Final counter value: " << counter << std::endl;
    return 0;
}