Comment les exceptions peuvent-elles être propagées entre les threads en C ?

Propagation des exceptions entre les threads

Dans les applications multithread, il est important de gérer les exceptions qui se produisent dans les threads de travail sans faire planter l'ensemble de l'application. Cet article explique comment propager les exceptions des threads de travail vers le thread principal, permettant à l'appelant de les gérer avec élégance.

Défis de la propagation des exceptions

Une approche naïve consiste à interceptez les exceptions dans les threads de travail et enregistrez leur type et leur message. Cependant, cette méthode est limitée à un ensemble spécifique de types d'exceptions et nécessite des modifications manuelles du code lors de l'ajout de nouvelles exceptions.

Propagation des exceptions à l'aide d'exception_ptr

C 11 introduit l'exception_ptr type, qui fournit un moyen sûr et flexible de stocker et de transporter des exceptions entre les threads. Dans cette approche :

1. Chaque thread de travail intercepte les exceptions et les stocke dans un exception_ptr.
2. Le thread principal vérifie les exception_ptrs pour voir si des exceptions se sont produites.
3. Si une exception est trouvée, le thread principal la renvoie, permettant à l'appelant de la gérer.

Exemple de code

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

static std::exception_ptr myException;

void f() {
    try {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        throw std::runtime_error("To be passed between threads");
    } catch (...) {
        myException = std::current_exception();  // Store the exception
    }
}

int main() {
    std::thread myThread(f);
    myThread.join();

    if (myException) {
        try {
            std::rethrow_exception(myException);  // Rethrow the exception
        } catch (const std::exception& ex) {
            std::cerr << "Thread exited with exception: " << ex.what() << "\n";
        }
    }

    return 0;
}</code>

Multi- Considérations sur les threads

Dans les scénarios avec plusieurs threads de travail, il est nécessaire d'utiliser un tableau d'exception_ptrs pour capturer les exceptions de chaque thread. De plus, exception_ptrs sont des pointeurs partagés, il est donc crucial de s'assurer qu'au moins un exception_ptr pointe vers chaque exception pour éviter une désallocation prématurée.

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!