C++如何在多线程中管理共享内存

使用互斥锁、原子操作、条件变量和线程局部存储可安全管理C++多线程共享内存。示例包括：std::mutex与std::lock_guard保护共享数据；std::atomic实现无锁计数；std::condition_variable协调生产者-消费者通信；thread_local避免共享。应根据场景选择合适机制以确保线程安全。

在C++多线程程序中，多个线程访问同一块共享内存时，容易引发数据竞争和未定义行为。要安全地管理共享内存，必须通过同步机制确保任意时刻只有一个线程能修改数据，或在特定条件下协调读写操作。

使用互斥锁（std::mutex）保护共享数据

最常见的方式是使用互斥锁来防止多个线程同时访问共享内存。

通过 std::mutex 和 std::lock_guard 或 std::unique_lock，可以自动加锁和释放锁，避免忘记解锁导致死锁。

#include 
#include 
#include 

std::vector shared_data;
std::mutex data_mutex;

void add_data(int value) {
    std::lock_guard lock(data_mutex);
    shared_data.push_back(value);
}

int main() {
    std::thread t1(add_data, 1);
    std::thread t2(add_data, 2);
    t1.join();
    t2.join();
    return 0;
}

每次对 shared_data 的修改都由 lock_guard 保证原子性，避免了数据竞争。

立即学习“C++免费学习笔记（深入）”；

使用原子操作（std::atomic）进行轻量级同步

对于简单的共享变量（如计数器），可以使用 std::atomic 避免加锁开销。

原子操作保证读写是不可分割的，适合标志位、计数等场景。

#include 
#include 

std::atomic counter{0};

void increment() {
    for (int i = 0; i < 1000; ++i) {
        counter.fetch_add(1);
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join();
    t2.join();
    // counter 正确等于 2000
    return 0;
}

使用条件变量协调线程间通信

当线程需要等待共享数据达到某种状态时，可结合 std::condition_variable 和互斥锁实现等待-通知机制。

蛙蛙写作——超级AI智能写作助手

蛙蛙写作辅助AI写文，帮助获取创意灵感，提供拆书、小说转剧本、视频生成等功能，是一款功能全面的AI智能写作工具。

下载

典型用于生产者-消费者模型。

#include 
#include 

std::queue message_queue;
std::mutex queue_mutex;
std::condition_variable cv;
bool finished = false;

void consumer() {
    while (true) {
        std::unique_lock lock(queue_mutex);
        cv.wait(lock, [] { return !message_queue.empty() || finished; });

        if (finished && message_queue.empty()) break;

        int msg = message_queue.front();
        message_queue.pop();
        lock.unlock();

        // 处理消息
        printf("Consumed: %d\n", msg);
    }
}

void producer() {
    for (int i = 1; i <= 5; ++i) {
        {
            std::lock_guard lock(queue_mutex);
            message_queue.push(i);
        }
        cv.notify_one();
    }
    {
        std::lock_guard lock(queue_mutex);
        finished = true;
    }
    cv.notify_one();
}

消费者在队列为空时等待，生产者添加数据后通知消费者，避免忙等待。

避免共享内存：使用线程局部存储或消息传递

最安全的方式是尽量减少共享状态。可使用 thread_local 让每个线程拥有独立副本。

或采用消息传递模型（如使用无锁队列），线程间不直接共享数据，而是通过传递所有权来通信。

thread_local int thread_id = 0;

void set_id(int id) {
    thread_id = id;
    printf("Thread %d running\n", thread_id);
}

每个线程有自己的 thread_id 副本，无需同步。

基本上就这些。关键是根据场景选择合适的同步方式：互斥锁保护复杂数据结构，原子变量处理简单共享变量，条件变量协调等待，尽量减少共享以提升性能和安全性。