面试题：C++ 中如何设计一个线程安全的类？

在C++中设计一个线程安全的类，意味着在多线程环境下，类的成员函数可以被多个线程安全地调用，而不会导致数据竞争或未定义行为。以下是设计线程安全类的一些关键步骤和注意事项：

1. 使用互斥锁（Mutex）保护共享数据

使用 std::mutex 或其它锁机制（如 std::shared_mutex）来保护类的内部状态。
在访问或修改共享数据时，加锁以确保同一时间只有一个线程可以访问。 示例：

   #include <mutex>
   #include <vector>

   class ThreadSafeVector {
   private:
       std::vector<int> data;
       mutable std::mutex mtx; // mutable 允许在 const 成员函数中加锁

   public:
       void push(int value) {
           std::lock_guard<std::mutex> lock(mtx);
           data.push_back(value);
       }

       size_t size() const {
           std::lock_guard<std::mutex> lock(mtx);
           return data.size();
       }
   };

2. 避免死锁

确保加锁的顺序一致，避免多个线程以不同的顺序请求锁。
使用 std::lock 或 std::scoped_lock（C++17）来一次性锁定多个互斥锁，避免死锁。 示例：

   class ThreadSafeBankAccount {
   private:
       double balance;
       std::mutex mtx;

   public:
       void transfer(ThreadSafeBankAccount& to, double amount) {
           std::lock(mtx, to.mtx); // 同时锁定两个互斥锁
           std::lock_guard<std::mutex> lock1(mtx, std::adopt_lock);
           std::lock_guard<std::mutex> lock2(to.mtx, std::adopt_lock);

           balance -= amount;
           to.balance += amount;
       }
   };

3. 使用原子操作

对于简单的数据类型（如 int、bool），可以使用 std::atomic 来避免锁的开销。
原子操作是无锁的，适合高性能场景。 示例：

   #include <atomic>

   class ThreadSafeCounter {
   private:
       std::atomic<int> count{0};

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

       int get() const {
           return count.load();
       }
   };

4. 避免返回内部数据的引用或指针

返回内部数据的引用或指针可能会导致线程安全问题，因为外部代码可以在不加锁的情况下直接修改数据。
如果需要返回数据，返回一个副本。 示例：

   class ThreadSafeVector {
   private:
       std::vector<int> data;
       mutable std::mutex mtx;

   public:
       std::vector<int> getData() const {
           std::lock_guard<std::mutex> lock(mtx);
           return data; // 返回副本
       }
   };

5. 使用条件变量（Condition Variable）实现线程间通信

如果类的某些操作需要等待特定条件，可以使用 std::condition_variable 来实现线程间的同步。 示例：

   #include <condition_variable>
   #include <queue>

   class ThreadSafeQueue {
   private:
       std::queue<int> queue;
       std::mutex mtx;
       std::condition_variable cv;

   public:
       void push(int value) {
           std::lock_guard<std::mutex> lock(mtx);
           queue.push(value);
           cv.notify_one(); // 通知等待的线程
       }

       int pop() {
           std::unique_lock<std::mutex> lock(mtx);
           cv.wait(lock, [this] { return !queue.empty(); }); // 等待队列不为空
           int value = queue.front();
           queue.pop();
           return value;
       }
   };