如何在Linux C++项目中实现细粒度的线程同步

在 Linux C++ 项目中实现细粒度的线程同步需要使用一些高级的同步原语

1. 使用互斥锁（std::mutex）：互斥锁是最基本的同步原语，用于保护共享资源免受多个线程同时访问的影响。在 C++11 及更高版本中，可以使用 std::mutex 和 std::lock_guard 或 std::unique_lock 来实现互斥锁。

#include <mutex>

std::mutex mtx; // 全局互斥锁

void thread_function() {
    std::lock_guard<std::mutex> lock(mtx); // 自动加锁
    // 访问共享资源
}

2. 使用条件变量（std::condition_variable）：条件变量用于在多个线程之间传递消息。它们通常与互斥锁一起使用，以确保在检查条件和等待通知时不会发生竞争条件。

#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void thread_function1() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; }); // 等待条件满足
    // 处理共享资源
}

void thread_function2() {
    std::lock_guard<std::mutex> lock(mtx);
    ready = true;
    cv.notify_one(); // 通知等待的线程
}

3. 使用原子操作（std::atomic）：原子操作是一种不可中断的操作，可以在不使用锁的情况下实现细粒度的同步。C++11 提供了 std::atomic 类型，可以用于实现原子操作。

#include <atomic>

std::atomic<int> counter(0); // 全局原子变量

void thread_function() {
    int local_counter = counter.fetch_add(1, std::memory_order_relaxed); // 原子加 1
    // 处理共享资源
}

4. 使用读写锁（std::shared_mutex）：读写锁允许多个线程同时读取共享资源，但在写入时会阻止其他线程访问。这在读操作远多于写操作的场景下非常有用。C++17 提供了 std::shared_mutex 类型。

#include <shared_mutex>

std::shared_mutex rw_mtx; // 全局读写锁

void read_function() {
    std::shared_lock<std::shared_mutex> lock(rw_mtx); // 读锁
    // 访问共享资源
}

void write_function() {
    std::unique_lock<std::shared_mutex> lock(rw_mtx); // 写锁
    // 修改共享资源
}

根据项目的需求和场景，可以选择适当的同步原语来实现细粒度的线程同步。在实际应用中，可能需要结合多种同步原语来确保线程安全。