Comment puis-je propager efficacement les exceptions entre les threads dans une application C multithread ?

Propagation des exceptions entre les threads

Dans les applications multithread, la gestion des exceptions des threads de travail peut être difficile. Il est essentiel d'éviter que les exceptions non gérées ne fassent planter l'ensemble de l'application et de fournir au thread principal un moyen de les gérer correctement.

Techniques de propagation des exceptions

L'approche suggérée dans la question implique de détecter les exceptions sur les threads de travail, d'enregistrer leur type et leur message, et de les renvoyer sur le thread principal à l'aide d'une instruction switch. Bien qu'efficace, il présente des limites dans la prise en charge d'un ensemble limité de types d'exceptions.

Une solution plus robuste consiste à exploiter le type exception_ptr introduit dans C 11. Exception_ptr permet de transporter des exceptions entre les threads.

Exemple avec Exception_ptr (C 11)

Le code suivant montre comment utiliser exception_ptr pour propager des exceptions entre plusieurs threads de travail et le thread principal :

<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>

Dans Dans cet exemple, un exception_ptr distinct est alloué à chaque thread de travail, permettant à plusieurs exceptions d'être levées et propagées au thread principal. Cette approche fournit une solution plus dynamique et flexible pour la gestion des exceptions dans les applications multithread.

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!