boost :: filo codice di uscita?

Question

Qual è il modo standard per ottenere un codice di uscita da un boost :: thread?
I documenti non sembrano toccare su questo tema a tutti.

Answer 1

Non so che il codice di uscita del filo è disponibile in quanto questo è il sistema operativo specifico. Si potrebbe simulare il superamento di un codice di uscita o un codice risultato facendo qualcosa di simile a questo:

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 non supporta i codici di ritorno da thread. Vi consiglio di usare un futuro: C ++ 11 prevede a termine nella libreria standard , o se siete su una versione precedente di C ++, il Boost.Thread biblioteca ha avuto un eccellente implementazione di future a partire dalla versione 1.41 . Questo vi dà una sintassi comune sia per il blocco e non-blocking di comunicazione, permette di ritornare qualsiasi tipo di oggetto, e come la ciliegina sulla torta consente di propagare le eccezioni di fili.

Answer 3

Dal momento che le copie Boost.Thread funtore si passa la soluzione di David non funzioneranno in alcun esempio del mondo reale. Che, fondamentalmente, sono due opzioni:

1. allocare una matrice di codici di uscita e passare un riferimento ad un codice di uscita univoco nel costruttore di ogni funtore. Piuttosto semplice da implementare.
2. Se si sta creando un solo filo da un particolare funtore, poi il funtore può contenere un puntatore intelligente condiviso a un allocata dinamicamente esiste codice che possono poi essere letti da oggetto functor originale.

Ecco alcuni esempi di ciascun metodo:

Metodo 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;
    }
}

Metodo 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;
}