Diese Frage sollte etwas einfacher sein als meine letzten. Ich habe die folgende Arbeitswarteschlange in mein Programm implementiert:

Pool.h:

// tpool class
// It's always closed. :glasses:
#ifndef __POOL_H
#define __POOL_H
class tpool {
    public:
        tpool( std::size_t tpool_size );
        ~tpool();
        template< typename Task >
        void run_task( Task task ){
        boost::unique_lock< boost::mutex > lock( mutex_ );
            if( 0 < available_ ) {
                --available_;
                io_service_.post( boost::bind( &tpool::wrap_task, this, boost::function< void() > ( task ) ) );
            }
        }
    private:
        boost::asio::io_service io_service_;
        boost::asio::io_service::work work_;
        boost::thread_group threads_;
        std::size_t available_;
        boost::mutex mutex_;
        void wrap_task( boost::function< void() > task );
};
extern tpool dbpool;
#endif

pool.cpp:

#include <boost/asio/io_service.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include "pool.h"
tpool::tpool( std::size_t tpool_size ) : work_( io_service_ ), available_( tpool_size ) {
    for ( std::size_t i = 0; i < tpool_size; ++i ){
        threads_.create_thread( boost::bind( &boost::asio::io_service::run, &io_service_ ) );
    }
}
tpool::~tpool() {
    io_service_.stop();
    try {
        threads_.join_all();
    }
    catch( ... ) {}
}
void tpool::wrap_task( boost::function< void() > task ) {
    // run the supplied task
    try {
        task();
    } // suppress exceptions
    catch( ... ) {
    }
    boost::unique_lock< boost::mutex > lock( mutex_ );
    ++available_;
}
tpool dbpool( 50 );

Das Problem ist jedoch, dass nicht alle meine Anrufe anrun_task() werden von Worker-Threads vervollständigt. Ich bin mir nicht sicher, ob es daran liegt, dass es nicht in die Warteschlange eingeht oder die Aufgabe verschwindet, wenn der Thread, der es erstellt hat, beendet wird.

Also meine Frage ist, gibt es etwas Besonderes, das ich @ geben muboost::thread, damit es wartet, bis die Warteschlange entsperrt ist? und wie lang ist die erwartete Lebensdauer einer Aufgabe, die in eine Warteschlange eingereiht wurde? Verlassen die Aufgaben den Gültigkeitsbereich, wenn der Thread, der sie erstellt hat, beendet wird? Wenn ja, wie kann ich das verhindern?

Bearbeiten: Ich habe die folgenden Änderungen an meinem Code vorgenommen:

template< typename Task >
void run_task( Task task ){ // add item to the queue
    io_service_.post( boost::bind( &tpool::wrap_task, this, boost::function< void() > ( task ) ) );
}

und jetzt werden alle Einträge korrekt eingegeben. Ich habe jedoch noch eine Frage: Wie lange werden die Aufgaben in der Warteschlange noch ausgeführt? Sind sie nicht mehr vorhanden, sobald der Thread, der sie erstellt hat, beendet wurde?