Wie gehe ich mit Thread-übergreifenden C++-Ausnahmen um?

In Multithread-C++ wird die Ausnahmebehandlung über die Mechanismen std::promise und std::future implementiert: Verwenden Sie das Promise-Objekt, um die Ausnahme in dem Thread aufzuzeichnen, der die Ausnahme auslöst. Verwenden Sie ein zukünftiges Objekt, um in dem Thread, der die Ausnahme empfängt, nach Ausnahmen zu suchen. Praktische Beispiele zeigen, wie man Versprechen und Futures verwendet, um Ausnahmen in verschiedenen Threads abzufangen und zu behandeln.

So behandeln Sie threadübergreifende C++-Ausnahmen

Vorwort

Bei der Multithread-Programmierung können Ausnahmen in jedem Thread ausgelöst werden. Die Thread-übergreifende Behandlung von Ausnahmen erfordert zusätzliche Überlegungen, da es keine explizite Kontrolle darüber gibt, wie und wo Ausnahmen ausgelöst werden.

Mechanismus zur Übermittlung von Ausnahmen

Die C++-Standardbibliothek bietet einen Mechanismus zur Übermittlung von Ausnahmen, genannt std::promise und std::future. Wir können sie verwenden, um Ausnahmen sicher zwischen Threads zu übergeben. 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 ist für die Generierung von Ausnahmen verantwortlich und std::future ist für den Empfang von Ausnahmen verantwortlich. Beide Objekte müssen im selben Thread erstellt werden: 🎜rrreee🎜 Wenn die Ausnahme in anderen Threads ausgelöst wird, können wir das promise-Objekt verwenden, um sie zu übergeben: 🎜rrreee🎜 Dann können wir sie im übergeben Hauptthread Verwenden Sie future-Objekte, um auf Ausnahmen zu prüfen: 🎜rrreee🎜Praktischer Fall🎜🎜Der folgende Code zeigt, wie std::promise und std::future verwendet werden So behandeln Sie Cross-Thread-Ausnahmen: 🎜rrreee🎜Fazit🎜🎜Durch die Verwendung von std::promise und std::future können wir Cross-Thread sicher behandeln Ausnahmen. Dadurch können wir die Ausführung fortsetzen, nachdem eine Ausnahme aufgetreten ist, und sie später behandeln. 🎜

Das obige ist der detaillierte Inhalt vonWie gehe ich mit Thread-übergreifenden C++-Ausnahmen um?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!