保证变量的可见性

在C++中，要保证变量的可见性，通常需要使用适当的同步机制，以确保变量的修改在多个线程之间是可见的。以下是几种常见的方法：

1. 使用互斥锁（Mutex）：可以使用std::mutex等互斥锁来保护共享变量的访问，通过在读写共享变量之前对互斥锁进行加锁，可以确保只有一个线程能够访问该变量，从而保证变量的可见性。

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

std::mutex mtx;
int sharedData = 0;

void threadFunction() {
    std::lock_guard<std::mutex> lock(mtx);
    sharedData++;
}

int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);

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

    std::cout << "Shared data: " << sharedData << std::endl;

    return 0;
}

2. 使用原子操作（Atomic Operations）：可以使用std::atomic模板类来定义原子变量，通过原子操作函数（如fetch_add()）来对变量进行操作，从而确保操作的原子性和可见性。

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

std::atomic<int> sharedData(0);

void threadFunction() {
    sharedData.fetch_add(1, std::memory_order_relaxed);
}

int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);

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

    std::cout << "Shared data: " << sharedData << std::endl;

    return 0;
}

3. 使用条件变量（Condition Variables）：可以使用std::condition_variable来实现线程之间的通信和同步，在共享变量发生改变时，通过条件变量来通知等待的线程，从而保证变量的可见性。

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

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

void producerFunction() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lock(mtx);
        dataReady = true;
    }
    cv.notify_one();
}

void consumerFunction() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return dataReady; });
    std::cout << "Data is ready!" << std::endl;
}

int main() {
    std::thread producer(producerFunction);
    std::thread consumer(consumerFunction);

    producer.join();
    consumer.join();

    return 0;
}

这些方法都可以确保共享变量的修改对于多个线程是可见的，从而保证了变量的可见性。选择合适的方法取决于具体的场景和需求。