C++ 异常安全与并发：确保多线程代码的异常安全性

C++ 异常安全与并发：确保多线程代码的异常安全性

大家好！今天咱们聊聊C++里两个让人头疼，但又不得不面对的家伙：异常安全和并发。单独拿出一个来，已经够你喝一壶的了，现在要把它们揉在一起，那酸爽，简直不敢相信。但别怕，今天咱们就来啃下这块硬骨头，让你的多线程代码也能优雅地处理异常，不再动不动就崩溃，留下满地鸡毛。

一、 啥是异常安全？为啥它这么重要？

想象一下，你正在做一个复杂的蛋糕。做着做着，突然发现烤箱坏了，蛋糕做不下去了。这时候，你需要做啥？难道直接把厨房炸了，然后跑路？当然不是！你应该收拾好已经用过的东西，把面粉、鸡蛋啥的都放回原位，让厨房恢复到开始做蛋糕之前的状态。

这就是异常安全的核心思想：当异常发生时，程序应该保持在一个一致的状态，不会泄漏资源，也不会破坏数据。

为啥它这么重要？因为C++的异常处理模型是基于RAII（Resource Acquisition Is Initialization，资源获取即初始化）的。RAII简单来说，就是用对象的生命周期来管理资源。当对象被销毁时，会自动释放其持有的资源。如果你的代码没有做好异常安全，当异常发生时，对象可能无法正常销毁，导致资源泄漏，甚至数据损坏。

异常安全级别：

• 无异常保证 (No-throw guarantee): 承诺操作永远不会抛出异常。通常用 noexcept 关键字标记。这是最理想的，但也是最难实现的。比如内存分配失败可能会抛出异常，但你可以通过预先分配内存池来避免。
• 基本异常安全保证 (Basic exception safety): 承诺如果操作抛出异常，程序不会泄漏资源，并且数据保持在一个有效的状态。但这个状态可能和操作开始前的状态不一样。 简单来说，就是“不死机，但可能吐血”。
• 强异常安全保证 (Strong exception safety): 承诺如果操作抛出异常，程序的状态会恢复到操作开始之前的状态。就像啥都没发生一样。 实现难度最高，通常需要copy-and-swap等技巧。
• 不提供任何保证 (No guarantee): 代码可能会泄漏资源，或者使数据处于不一致的状态。这是最糟糕的情况，应该避免。

表格：异常安全级别对比

异常安全级别	保证	实现难度
无异常保证	操作永远不会抛出异常	最高
基本异常安全	程序不会泄漏资源，数据保持有效状态（但可能与操作前不同）	中等
强异常安全	程序的状态恢复到操作开始之前的状态	非常高
不提供任何保证	代码可能会泄漏资源，或者使数据处于不一致的状态	最低

二、 并发编程中的异常安全：更复杂的挑战

现在，把异常安全放到多线程环境中，难度直接翻倍。多个线程同时访问和修改共享数据，如果一个线程抛出异常，可能会导致其他线程的数据损坏，甚至死锁。

想象一下，多个厨师同时在一个厨房里做蛋糕。一个厨师突然切到手了，把面粉撒了一地，还碰倒了另一个厨师正在做的奶油。这下可好，整个厨房都乱套了。

并发中的异常安全需要考虑以下几个方面：

1. 数据竞争 (Data Race)： 多个线程同时访问和修改同一个共享变量，且至少有一个线程是写操作。 这会导致未定义的行为。

2. 死锁 (Deadlock)： 多个线程互相等待对方释放资源，导致所有线程都无法继续执行。

3. 活锁 (Livelock)： 多个线程不断重试一个操作，但由于某种原因，总是失败。 就像两个人同时想从一个门里过，都互相让对方先走，结果谁也走不了。

4. 资源泄漏 (Resource Leak)： 线程抛出异常时，没有正确释放持有的资源（例如锁、内存、文件句柄）。

三、 如何编写异常安全的并发代码？

好，现在咱们来聊聊如何编写异常安全的并发代码。记住，没有银弹，只有各种各样的技巧和策略，需要根据具体情况选择合适的方案。

1. RAII (Resource Acquisition Is Initialization):

RAII 是解决资源泄漏问题的利器。它利用对象的生命周期来管理资源。当对象被创建时，获取资源；当对象被销毁时，释放资源。即使发生异常，对象也会被正确销毁，从而释放资源。

举个例子：使用 std::lock_guard 管理锁

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

std::mutex mtx; // 互斥锁

void do_something() {
  std::lock_guard<std::mutex> lock(mtx); // 获取锁，lock_guard对象构造时获取锁，析构时释放锁
  // 在锁的保护下访问共享资源
  std::cout << "Thread ID: " << std::this_thread::get_id() << " - Doing something..." << std::endl;
  // 模拟可能抛出异常的操作
  //throw std::runtime_error("Something went wrong!");
}

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

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

  return 0;
}

在这个例子中，std::lock_guard 对象在构造时获取锁，在析构时释放锁。即使 do_something() 函数抛出异常，lock_guard 对象也会被销毁，从而释放锁，避免死锁。

2. 使用智能指针 (Smart Pointers):

智能指针可以自动管理动态分配的内存，避免内存泄漏。C++提供了三种智能指针：std::unique_ptr、std::shared_ptr 和 std::weak_ptr。

• std::unique_ptr: 独占所有权，只能有一个 unique_ptr 指向一个对象。
• std::shared_ptr: 共享所有权，多个 shared_ptr 可以指向同一个对象。当最后一个 shared_ptr 被销毁时，对象会被自动释放。
• std::weak_ptr: 弱引用，不增加对象的引用计数。用于解决 shared_ptr 循环引用的问题。

举个例子：使用 std::shared_ptr 管理共享数据

#include <iostream>
#include <memory>
#include <thread>
#include <vector>

class Data {
public:
  Data(int value) : value_(value) {
    std::cout << "Data created with value: " << value_ << std::endl;
  }
  ~Data() {
    std::cout << "Data destroyed with value: " << value_ << std::endl;
  }

  int getValue() const { return value_; }
  void setValue(int value) { value_ = value; }

private:
  int value_;
};

void process_data(std::shared_ptr<Data> data) {
  try {
    // 使用共享数据
    std::cout << "Thread ID: " << std::this_thread::get_id() << " - Processing data: " << data->getValue() << std::endl;
    // 模拟可能抛出异常的操作
    //throw std::runtime_error("Error in process_data!");
  } catch (const std::exception& e) {
    std::cerr << "Exception in process_data: " << e.what() << std::endl;
  }
}

int main() {
  std::shared_ptr<Data> data = std::make_shared<Data>(42); // 创建共享数据

  std::vector<std::thread> threads;
  for (int i = 0; i < 3; ++i) {
    threads.emplace_back(process_data, data); // 将 shared_ptr 传递给线程
  }

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

  return 0;
}

在这个例子中，std::shared_ptr 保证了即使 process_data() 函数抛出异常，Data 对象也会被正确释放。

3. 使用 try-catch 块处理异常：

try-catch 块是处理异常的基本工具。你应该在可能抛出异常的代码块周围加上 try-catch 块，并在 catch 块中处理异常。

注意： 不要捕获所有异常 (catch(…))。 这样做可能会隐藏一些严重的错误，使你无法正确处理。 应该只捕获你能够处理的异常。

4. 原子操作 (Atomic Operations)：

原子操作是不可分割的操作。它们可以保证在多线程环境下对共享变量的访问是线程安全的，避免数据竞争。C++提供了 std::atomic 类来支持原子操作。

举个例子：使用 std::atomic 计数器

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

std::atomic<int> counter(0); // 原子计数器

void increment_counter() {
  for (int i = 0; i < 10000; ++i) {
    counter++; // 原子递增操作
  }
}

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

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

  std::cout << "Counter value: " << counter << std::endl; // 输出计数器的值，应该是 20000
  return 0;
}

在这个例子中，counter 是一个原子变量。counter++ 是一个原子递增操作，可以保证在多线程环境下对 counter 的访问是线程安全的。

5. Copy-and-Swap 策略：

Copy-and-Swap 是一种实现强异常安全保证的常用策略。它的基本思想是：

1. 创建一个数据的副本。
2. 在副本上进行修改。
3. 如果修改成功，则将副本与原始数据进行交换。
4. 如果修改失败，则丢弃副本，原始数据保持不变。

举个例子：使用 Copy-and-Swap 修改数据

#include <iostream>
#include <mutex>
#include <algorithm>
#include <vector>

class SafeVector {
public:
  SafeVector() {}
  SafeVector(const SafeVector& other) : data_(other.data_) {} // 拷贝构造函数

  SafeVector& operator=(const SafeVector& other) {
    if (this != &other) {
      SafeVector temp(other); // 创建副本
      swap(temp);            // 交换数据
    }
    return *this;
  }

  void push_back(int value) {
    std::lock_guard<std::mutex> lock(mtx_);
    std::vector<int> temp = data_; // 创建副本
    temp.push_back(value);       // 在副本上修改
    swap(temp);                   // 交换数据
  }

  int at(size_t index) const {
    std::lock_guard<std::mutex> lock(mtx_);
    return data_.at(index);
  }

private:
  void swap(SafeVector& other) {
    std::lock_guard<std::mutex> lock1(mtx_);
    std::lock_guard<std::mutex> lock2(other.mtx_); //防止自交换死锁
    std::swap(data_, other.data_);
  }

  std::vector<int> data_;
  mutable std::mutex mtx_;
};

int main() {
  SafeVector vec;
  vec.push_back(1);
  vec.push_back(2);
  std::cout << vec.at(0) << std::endl; // 输出 1
  return 0;
}

在这个例子中，push_back() 函数使用了 Copy-and-Swap 策略。它首先创建一个 data_ 的副本 temp，然后在 temp 上进行修改。如果修改成功，则调用 swap() 函数将 temp 与 data_ 进行交换。如果修改失败，则丢弃 temp，data_ 保持不变。

6. 避免共享状态 (Avoid Shared State)：

减少共享状态是降低并发复杂性的一个重要手段。如果线程之间不需要共享数据，就可以避免数据竞争和死锁等问题。

尽量使用线程局部存储 (Thread-Local Storage) 来存储线程私有的数据。

7. 使用消息队列 (Message Queues)：

消息队列是一种线程间通信的方式。线程可以通过消息队列来发送和接收消息，而不需要直接访问共享数据。这可以降低线程之间的耦合度，提高程序的可靠性。

8. 使用并发容器 (Concurrent Containers)：

C++17 引入了一些并发容器，例如 std::queue 和 std::map 的并发版本。这些容器提供了线程安全的访问接口，可以简化并发编程。

9. 谨慎使用锁 (Careful Use of Locks)：

锁是保护共享资源的重要手段，但使用不当会导致死锁。

• 避免持有锁的时间过长。
• 避免嵌套锁。 如果必须使用嵌套锁，确保以相同的顺序获取和释放锁。
• 使用超时锁 (Timed Locks)。 如果无法在指定的时间内获取锁，则放弃获取，避免死锁。

10. 异常处理的思考:

• 哪里抛出异常？: 仔细分析代码，确定哪些地方可能抛出异常。
• 谁来捕获异常？: 确定哪个线程或函数负责捕获和处理异常。
• 如何处理异常？: 确定如何处理异常，例如回滚操作、释放资源、记录日志等。
• 异常处理对其他线程的影响？: 考虑异常处理是否会影响其他线程的执行。

四、 一个更复杂的例子：线程池中的异常安全

现在，咱们来看一个更复杂的例子：线程池。线程池是一种常用的并发编程模式，它可以提高程序的性能和可伸缩性。

#include <iostream>
#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>

class ThreadPool {
public:
  ThreadPool(size_t num_threads) : stop_(false) {
    threads_.resize(num_threads);
    for (size_t i = 0; i < num_threads; ++i) {
      threads_[i] = std::thread([this] {
        while (true) {
          std::function<void()> task;

          {
            std::unique_lock<std::mutex> lock(queue_mutex_);
            condition_.wait(lock, [this] { return stop_ || !tasks_.empty(); });
            if (stop_ && tasks_.empty()) {
              return;
            }
            task = std::move(tasks_.front());
            tasks_.pop();
          }

          try {
            task(); // 执行任务，捕获异常
          } catch (const std::exception& e) {
            std::cerr << "Exception in thread: " << std::this_thread::get_id() << " - " << e.what() << std::endl;
            // 在这里可以采取一些恢复措施，例如重新提交任务或者记录错误日志
          }
        }
      });
    }
  }

  ~ThreadPool() {
    {
      std::unique_lock<std::mutex> lock(queue_mutex_);
      stop_ = true;
    }
    condition_.notify_all();
    for (std::thread& thread : threads_) {
      thread.join();
    }
  }

  template <typename F>
  void enqueue(F task) {
    {
      std::unique_lock<std::mutex> lock(queue_mutex_);
      tasks_.emplace(task);
    }
    condition_.notify_one();
  }

private:
  std::vector<std::thread> threads_;
  std::queue<std::function<void()>> tasks_;
  std::mutex queue_mutex_;
  std::condition_variable condition_;
  bool stop_;
};

int main() {
  ThreadPool pool(4); // 创建一个包含 4 个线程的线程池

  for (int i = 0; i < 10; ++i) {
    pool.enqueue([i] {
      std::cout << "Task " << i << " started by thread: " << std::this_thread::get_id() << std::endl;
      // 模拟可能抛出异常的任务
      if (i == 5) {
        throw std::runtime_error("Task 5 failed!");
      }
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
      std::cout << "Task " << i << " finished by thread: " << std::this_thread::get_id() << std::endl;
    });
  }

  std::this_thread::sleep_for(std::chrono::seconds(1)); // 等待任务完成
  return 0;
}

在这个例子中，线程池的每个线程都包含一个 try-catch 块，用于捕获任务执行过程中抛出的异常。如果任务抛出异常，线程会记录错误日志，并继续执行下一个任务。 这样可以保证线程池的稳定性，即使某些任务失败，也不会导致整个线程池崩溃。

五、 总结：掌握异常安全，征服并发编程

异常安全和并发编程是C++中两个重要的概念。掌握它们可以让你编写出更健壮、更可靠的多线程代码。 记住，没有一劳永逸的解决方案，需要根据具体情况选择合适的策略。 多练习，多思考，你就能征服这些挑战，成为真正的C++大师！

希望今天的讲座对大家有所帮助！谢谢！