C++ concurrent programming: How to deal with exception handling in a multi-threaded environment?

The Multithreaded C Exception Handling Guide proposes four key approaches: Use mutexes or atomic operations to ensure thread safety in exception handling. Leverage thread-local storage (TLS) to store exception information for each thread. Implement asynchronous tasks and exception propagation through std::async and std::future. Collect exception information through TLS and the main thread to implement exception handling in multi-threaded file downloads.

C Concurrent Programming: A Practical Guide to Multi-Threaded Exception Handling

In a multi-threaded environment, exception handling is particularly critical. It can ensure that the application will It can still operate normally under any circumstances. This article will introduce how to handle exceptions in a multi-threaded environment in C and demonstrate it through a practical case.

Exception synchronization and thread safety

In a multi-threaded environment, the throwing and handling of exceptions need to be synchronized to ensure that no data competition or deadlock occurs. You can use mutexes or atomic operations to ensure thread safety in exception handling.

// 使用互斥量实现线程安全异常处理
std::mutex m;
void handle_error() {
  std::unique_lock<std::mutex> lock(m);
  // 处理异常
}

Thread-Local Storage

Thread-local storage (TLS) can provide a separate storage area for each thread to store data specific to that thread, including Exception information.

// 使用 TLS 存储每个线程的异常信息
__thread std::exception_ptr exception_ptr;
void set_exception(const std::exception& e) {
  exception_ptr = std::make_exception_ptr(e);
}

Exception propagation and handling

In a multi-threaded environment, exceptions can be propagated from one thread to another. You can use std::async and std::future to execute tasks asynchronously and handle exceptions thrown in threads.

// 在异步任务中处理异常
auto f = std::async(std::launch::async, []() {
  try {
    // 执行任务
  } catch (const std::exception& e) {
    std::cout << "Exception caught in async task: " << e.what() << std::endl;
  }
});

// 在主线程中检查异常
if (f.get()) {
  std::cout << "Async task completed successfully" << std::endl;
} else {
  std::cout << "Async task failed with exception" << std::endl;
}

Practical case: multi-threaded file download

Consider a multi-threaded file download application where each thread is responsible for downloading a part of the file. To handle exceptions, we can use TLS to store exception information for download failures and collect this information in the main thread.

#include <thread>
#include <vector>
#include <iostream>
#include <fstream>

using namespace std;

// TLS 存储下载失败的异常信息
__thread exception_ptr exception_ptr;

// 下载文件的线程函数
void download_file(const string& url, const string& path) {
  try {
    ofstream file(path, ios::binary);
    // 略：从 URL 下载数据并写入文件
  } catch (const exception& e) {
    exception_ptr = make_exception_ptr(e);
  }
}

// 主线程函数
int main() {
  // 创建下载线程
  vector<thread> threads;
  for (const auto& url : urls) {
    string path = "file_" + to_string(i) + ".txt";
    threads.emplace_back(download_file, url, path);
  }

  // 加入线程并收集异常信息
  for (auto& thread : threads) {
    thread.join();
    if (exception_ptr) {
      try {
        rethrow_exception(exception_ptr);
      } catch (const exception& e) {
        cerr << "File download failed: " << e.what() << endl;
      }
    }
  }

  return 0;
}

Through these methods, we can effectively handle exceptions in C multi-threaded environment and ensure the robustness and stability of the application.

The above is the detailed content of C++ concurrent programming: How to deal with exception handling in a multi-threaded environment?. For more information, please follow other related articles on the PHP Chinese website!