为了实现线程安全性，c++++ 中有两种方法：使用互斥量保护临界区，允许一次只有一个线程访问。使用原子操作，以不可分割的方式执行操作，消除了并发访问问题。

C++ 类设计中实现线程安全性

引言

在多线程环境中，保证数据的线程安全性至关重要。C++ 中有几种方法可以实现这一点。本文将探讨如何使用互斥量和原子操作来设计线程安全的类。

互斥量

互斥量是一种锁机制，它允许一次只能有一个线程访问临界区。当一个线程进入临界区时，它会获取互斥量的所有权。其他线程在试图进入临界区时会阻塞，直到该线程释放互斥量。

class ThreadSafeCounter {
private:
    std::mutex m_mutex;
    int m_count;

public:
    void increment() {
        std::lock_guard<std::mutex> lock(m_mutex);
        ++m_count;
    }

    int get() {
        std::lock_guard<std::mutex> lock(m_mutex);
        return m_count;
    }
};

在上面的示例中，increment() 和 get() 方法都使用标准库中的 std::mutex 保护临界区。当一个线程正在更新计数时，其他线程无法同时进入 increment() 方法。

原子操作

原子操作是一种特殊类型的操作，它以不可分割的方式执行。这意味着一次只能在单个线程中执行这些操作，从而消除了并发访问引发的问题。C++11 中引入了 std::atomic 库，它提供了用于原子操作的类。

class ThreadSafeCounterAtomic {
private:
    std::atomic<int> m_count;

public:
    void increment() {
        ++m_count;
    }

    int get() {
        return m_count.load();
    }
};

在本例中，m_count 是一个原子整数，可以安全地从多个线程中进行增量和获取。std::atomic::load() 方法以线程安全的方式获取原子整数的值。

实战案例

考虑一个需要从多个线程并行更新的共享计数器的示例：

#include <thread>

int main() {
    std::unique_ptr<ThreadSafeCounter> counter = std::make_unique<ThreadSafeCounter>();

    std::vector<std::thread> threads(10);
    for (auto& thread : threads) {
        thread = std::thread([&] {
            for (int i = 0; i < 1000000; ++i) {
                counter->increment();
            }
        });
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "最终计数：" << counter->get() << std::endl;
}

在这个程序中，我们从 10 个线程并行更新计数器，然后在主线程中打印最终计数。互斥量可确保计数器在任何时刻最多只能由一个线程更新，从而保证线程安全性。

结论

通过使用互斥量和原子操作，可以设计线程安全的 C++ 类。互斥量适用于保护需要串行访问的临界区，而原子操作适用于无需串行访问且可以原子方式执行的操作。