c++中 多线程如何共享变量

在 C++ 中，多线程共享变量需要注意线程安全问题，即避免多个线程同时对同一个变量进行读写操作。下面介绍几种常见的实现方式：

1. 使用互斥锁（mutex）来保护共享变量，即在访问共享变量之前先加锁，等操作完成后再解锁。这样可以保证同一时间只有一个线程可以访问该变量。示例代码如下：

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

std::mutex mtx; // 创建互斥锁

void func(int& shared_var) {
    for (int i = 0; i < 10000; ++i) {
        mtx.lock(); // 加锁
        shared_var++;
        mtx.unlock(); // 解锁
    }
}

int main() {
    int shared_var = 0;
    std::thread t1(func, std::ref(shared_var));
    std::thread t2(func, std::ref(shared_var));
    t1.join();
    t2.join();
    std::cout << "shared_var = " << shared_var << std::endl;
    return 0;
}

2. 使用原子变量（atomic），原子变量可以保证同一时间只有一个线程可以对其进行读写操作，避免数据竞争。示例代码如下：

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> shared_var(0); // 创建原子变量

void func() {
    for (int i = 0; i < 10000; ++i) {
        shared_var++;
    }
}

int main() {
    std::thread t1(func);
    std::thread t2(func);
    t1.join();
    t2.join();
    std::cout << "shared_var = " << shared_var << std::endl;
    return 0;
}

3. 使用条件变量（condition_variable）和锁来实现线程间的同步。条件变量可以用来等待某个条件的发生，当条件满足时，唤醒等待的线程。示例代码如下：

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

std::mutex mtx; // 创建互斥锁
std::condition_variable cv; // 创建条件变量
int shared_var = 0;
bool ready = false;

void func1() {
    for (int i = 0; i < 10000; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        shared_var++;
    }
    ready = true;
    cv.notify_one(); // 唤醒一个等待的线程
}

void func2() {
    std::unique_lock<std::mutex> lock(mtx);
    while (!ready) {
        cv.wait(lock); // 等待条件变量的通知
    }
    std::cout << "shared_var = " << shared_var << std::endl;
}

int main() {
    std::thread t1(func1);
    std::thread t2(func2);
    t1.join();
    t2.join();
    return 0;
}