boost :: code de sortie de thread?

Question

Quelle est la manière standard d'obtenir un code de sortie à partir d'un boost :: thread?
The docs ne semblent pas toucher à ce sujet du tout.

Answer 1

Je ne sais pas si le code de sortie de thread est disponible en tant que système d'exploitation spécifique. Vous pouvez simuler le passage d'un code de sortie ou code de résultat en faisant quelque chose comme ceci:

struct callable { 
    int result; 
    void operator()() 
    { 
     result = 42; 
    } 
}; 

void process_on_thread() { 
    callable x; 
    boost::thread processor(x); 

    processor.join(); 
    int result = x.result; 
} 

Answer 2

Posix ne supporte pas les codes de retour de fils. Je vous recommande d'utiliser un avenir: C++11 provides futures in the standard library, ou si vous êtes sur une ancienne version de C++, le Boost.Thread library a eu une excellente mise en œuvre des contrats à terme since version 1.41. Cela vous donne une syntaxe commune pour la communication à la fois bloquante et non bloquante, vous permet de retourner n'importe quel type d'objet, et comme le glaçage sur le gâteau vous permet de propager des exceptions à partir de threads.

Answer 3

Depuis Boost.Thread copie le foncteur que vous lui transmettez la solution de David ne fonctionnera pas dans un exemple réel. Vous avez essentiellement deux options:

1. Affectez un tableau de codes de sortie et transmettez une référence à un code de sortie unique dans le constructeur de chaque foncteur. Assez simple à mettre en œuvre.
2. Si vous ne créez qu'un seul thread à partir d'un foncteur particulier, alors le foncteur peut contenir un pointeur intelligent partagé vers un code existant alloué dynamiquement qui peut ensuite être lu par l'objet fonctor original.

Voici des exemples de chaque méthode:

Méthode 1:

#include <boost/thread/thread.hpp> 
#include <boost/thread/xtime.hpp> 
#include <boost/shared_ptr.hpp> 

#include <iostream> 

struct thread_alarm 
{ 
    thread_alarm(int secs, int &ec) : m_secs(secs), exit_code(ec) { } 
    void operator()() 
    { 
     boost::xtime xt; 
     boost::xtime_get(&xt, boost::TIME_UTC); 
     xt.sec += m_secs; 

     boost::thread::sleep(xt); 

     std::cout << "alarm sounded..." << std::endl; 

     exit_code = 0xDEADBEEF; 
    } 

    int m_secs; 
    int &exit_code; 
}; 

typedef boost::shared_ptr<boost::thread> BoostThreadPtr; 

int main(int argc, char* argv[]) 
{ 
    int secs = 1; 
    int exit_codes[10]; 

    BoostThreadPtr threads[10]; 

    for (int i = 0; i<10; ++i) { 
     std::cout << "setting alarm for 1 seconds..." << std::endl; 
     thread_alarm alarm(secs, exit_codes[i]); 
     threads[i] = BoostThreadPtr(new boost::thread(alarm)); 
    } 

    for (int i = 0; i<10; ++i) { 
     threads[i]->join(); 
     std::cout << "exit code == 0x" << std::hex << exit_codes[i] << std::endl; 
    } 
} 

Méthode 2:

#include <boost/thread/thread.hpp> 
#include <boost/thread/xtime.hpp> 
#include <boost/shared_ptr.hpp> 

#include <iostream> 

struct thread_alarm 
{ 
    thread_alarm(int secs) : m_secs(secs) { exit_code = IntPtr(new int(0)); } 
    void operator()() 
    { 
     boost::xtime xt; 
     boost::xtime_get(&xt, boost::TIME_UTC); 
     xt.sec += m_secs; 

     boost::thread::sleep(xt); 

     std::cout << "alarm sounded..." << std::endl; 

     *exit_code = 0xDEADBEEF; 
    } 

    int m_secs; 

    typedef boost::shared_ptr<int> IntPtr; 
    IntPtr exit_code; 
}; 

int main(int argc, char* argv[]) 
{ 
    int secs = 5; 
    std::cout << "setting alarm for 5 seconds..." << std::endl; 
    thread_alarm alarm(secs); 
    boost::thread thrd(alarm); 
    thrd.join(); 
    std::cout << "exit code == 0x" << std::hex << *(alarm.exit_code) << std::endl; 
}