How can I effectively propagate exceptions between threads in a multi-threaded C application?

Propagating Exceptions Between Threads

In multi-threaded applications, handling exceptions from worker threads can be challenging. It's essential to avoid having unhandled exceptions crash the entire application and provide a way for the main thread to handle them gracefully.

Techniques for Exception Propagation

The approach suggested in the question involves catching exceptions on worker threads, recording their type and message, and re-throwing them on the main thread using a switch statement. While effective, it has limitations in supporting a limited set of exception types.

A more robust solution is to leverage the exception_ptr type introduced in C 11. Exception_ptr allows exceptions to be transported between threads.

Example with Exception_ptr (C 11)

The following code demonstrates how to use exception_ptr to propagate exceptions between multiple worker threads and the main thread:

<code class="cpp">#include <iostream>
#include <thread>
#include <exception>
#include <stdexcept>

std::exception_ptr* exceptions[MAX_THREADS]; // Array to store exceptions from worker threads

void f(int id)
{
    try
    {
        // Simulated work
        std::this_thread::sleep_for(std::chrono::seconds(1));
        throw std::runtime_error("Exception in thread " + std::to_string(id));
    }
    catch (...)
    {
        exceptions[id] = std::current_exception();
    }
}

int main()
{
    std::thread threads[MAX_THREADS];

    // Start worker threads
    for (int i = 0; i < MAX_THREADS; i++)
    {
        threads[i] = std::thread(f, i);
    }

    // Wait for threads to finish
    for (int i = 0; i < MAX_THREADS; i++)
    {
        threads[i].join();
    }

    // Check for and propagate exceptions
    for (int i = 0; i < MAX_THREADS; i++)
    {
        if (exceptions[i])
        {
            try
            {
                std::rethrow_exception(*exceptions[i]);
            }
            catch (const std::exception& ex)
            {
                std::cerr << "Thread " << i << " exited with exception: " << ex.what() << "\n";
            }
        }
    }

    return 0;
}</code>

In this example, a separate exception_ptr is allocated for each worker thread, allowing multiple exceptions to be thrown and propagated to the main thread. This approach provides a more dynamic and flexible solution for exception handling in multi-threaded applications.

The above is the detailed content of How can I effectively propagate exceptions between threads in a multi-threaded C application?. For more information, please follow other related articles on the PHP Chinese website!