Comment gérer les exceptions C++ cross-thread ?

En C++ multithread, la gestion des exceptions est implémentée via les mécanismes std::promise et std::future : utilisez l'objet promise pour enregistrer l'exception dans le thread qui lève l'exception. Utilisez un objet futur pour rechercher des exceptions dans le thread qui reçoit l'exception. Des exemples pratiques montrent comment utiliser les promesses et les contrats à terme pour détecter et gérer les exceptions dans différents threads.

Comment gérer les exceptions C++ cross-thread

Avant-propos

Dans la programmation multithread, des exceptions peuvent être lancées dans n'importe quel thread. La gestion des exceptions entre les threads nécessite des considérations supplémentaires car il n'existe aucun contrôle explicite sur la manière et l'endroit où les exceptions sont levées.

Mécanisme de délivrance d'exceptions

La bibliothèque standard C++ fournit un mécanisme pour délivrer des exceptions, appelé std::promise et std::future. Nous pouvons les utiliser pour transmettre en toute sécurité des exceptions entre les threads. std::promise 和 std::future。我们可以使用它们来安全地在线程之间传递异常。

std::promise 负责生成异常，而 std::future 负责接收异常。两个对象必须在同一个线程中创建：

// 在主线程创建
std::promise<void> promise;
std::future<void> future = promise.get_future();

当异常在其他线程中抛出时，我们可以使用 promise 对象将其传递：

// 在 worker 线程
try {
  // ... 代码可能会抛出异常
}
catch (const std::exception& e) {
  promise.set_exception(std::make_exception_ptr(e));
}

然后，可以在主线程中使用 future 对象来检查异常：

// 在主线程
try {
  future.get();
}
catch (const std::exception& e) {
  // 处理异常
}

实战案例

以下代码展示了如何使用 std::promise 和 std::future 来处理跨线程异常：

#include <iostream>
#include <future>
#include <thread>

// 打印函数以展示在不同线程中抛出的异常
void printFunction() {
  try {
    throw std::runtime_error("这是一个运行时错误！");
  }
  catch (const std::exception& e) {
    std::cerr << "Worker 线程捕获异常：" << e.what() << '\n';
  }
}

int main() {
  std::promise<void> promise;
  std::future<void> future = promise.get_future();

  // 在新线程中运行打印函数
  std::thread worker(printFunction);

  // 让主线程等待 worker 线程
  try {
    future.get();
  }
  catch (const std::exception& e) {
    std::cerr << "主线程捕获异常：" << e.what() << '\n';
  }

  worker.join();
  return 0;
}

结论

通过使用 std::promise 和 std::future

std::promise est responsable de la génération des exceptions, et std::future est responsable de la réception des exceptions. Les deux objets doivent être créés dans le même thread : 🎜rrreee🎜 Lorsque l'exception est levée dans d'autres threads, nous pouvons utiliser l'objet promise pour la transmettre : 🎜rrreee🎜 Ensuite, nous pouvons la transmettre dans le fil principal Utilisez les objets future pour vérifier les exceptions : 🎜rrreee🎜Cas pratique🎜🎜Le code suivant montre comment utiliser std::promise et std::future Pour gérer les exceptions cross-thread : 🎜rrreee🎜Conclusion🎜🎜En utilisant std::promise et std::future, nous pouvons gérer en toute sécurité les cross-thread des exceptions. Cela nous permet de poursuivre l'exécution après qu'une exception se produit et de la gérer plus tard. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!