Question

I have a problem about the managed of thread.

My problem is that I want to create a class ThreadManager that have to manage all thread created and of course also destroy this thread.

class DerivedInterface
{
public:
    DerivedInterface():id("Test"){};
    virtual ~DerivedInterface(){};
    virtual void run() = 0;
    virtual std::string getId() = 0;
    const std::string  id ;
};

class Object : public DerivedInterface
{
public:
    Object():id("VirtualDae"){};
    ~Object(){}

    void run()
    {

        std::cout<<"i'M IN RUN"<<std::endl;

        bool flag = true;

        while(flag){
            //allocate x resources

            try{
                //do some process on resources
                boost::this_thread::sleep(boost::posix_time::milliseconds(100));
                //clean resources
            }
            catch(boost::thread_interrupted const& )
            {
                //clean resources
                std::cout << "Worker thread interrupted" << std::endl;
                flag = false;
            }
            catch(std::exception x){
                std::cout<<"exx"<<x.what()<<std::endl;
            }
        }
    }
    std::string getId(){
        return id;
    }

    const std::string  id ;
};
class ThreadManager
{
public:

void createThread(DerivedInterface& t)
{
    boost::thread t1(&DerivedInterface::run, &t); 
    insert(&t1);

}

     }
/*
 * This method insert the pointer of the thread in a
 * map
 */

void insert(boost::thread* t1)
{

    boost::mutex::scoped_lock lock(m_mutex);

    int size = threadsMap.size()+1;

    std::cout<<"Size :"<<size<<std::endl;

    threadsMap.insert(std::make_pair(size, t1));
}

/*
 * This method return the pointer of the thread
 * inserted in a map
 */

boost::thread*  get(int key){

    boost::mutex::scoped_lock lock(m_mutex);

    if(threadsMap.find(key)!=threadsMap.end()){
        std::cout<<"non null get"<<std::endl;

        return threadsMap[key];
    }else{
        std::cout<<" null get"<<std::endl;
        return NULL;
    }
}


/*
 * This method stop the thread corrisponding
 * to the position pos as parameter in the map
 */
void stop(int pos){
    std::cout<<"Stop"<<std::endl;

    boost::thread* thread = get(pos);

    std::cout<<"thread  null"<<std::endl;

    if(thread != NULL)
    {
        std::cout<<"thread not null"<<std::endl;
        thread->interrupt();

        std::cout << "Worker thread finished" << std::endl;
    }
}

     private:

boost::shared_ptr<boost::thread> _mThread;

typedef std::map<int, boost::thread*> ThreadMapT;

ThreadMapT threadsMap;

std::map<int,boost::thread*>::iterator it;

boost::mutex m_mutex;

boost::thread_group g;

     };


   int main(){

    ThreadManager manager;
Object v;
//
manager.createThread(v);

std::cout<<"Interrupt"<<std::endl;

boost::thread *t1= manager.get(1);

t1->interrupt();
//
boost::posix_time::time_duration timeout = boost::posix_time::milliseconds(10000);
if (manager.get(1)->timed_join(timeout))
{
    //finished
    std::cout << "Worker thread finished" << std::endl;
}
else
{
    //Not finished;
    std::cout << "Worker thread not finished" << std::endl;
}

     }  

the function t1.interrupt or manager.stop return segmantation fault ..

Program terminated with signal 11, Segmentation fault.
#0  0x00007f3e1d095993 in boost::thread::get_thread_info() const () from libboost_thread.so.1.51.0
(gdb) where
#0  0x00007f3e1d095993 in boost::thread::get_thread_info() const () from libboost_thread.so.1.51.0
#1  0x00007f3e1d0965c6 in boost::thread::interrupt() () from libboost_thread.so.1.51.0
#2  0x00000000004088a9 in main ()

Pointer of boost::thread is not null, so what happen? Thank you in advance.

Whey I can’t do something like this ?

boost::thread *t1 = new boost::thread(&DerivedInterface::run, &t);

Answer 1

void createThread(DerivedInterface& t)
{
    boost::thread t1(&DerivedInterface::run, &t); 
    insert(&t1);
}

In the above t1 object gets created on the stack, then a pointer to t1 gets inserted into the map and then t1 goes out of scope and gets destroyed, so that all existing pointers to it become invalid.

You can fix it by passing around shared_ptr<thread> instead of thread*:

void insert(boost::shared_ptr<boost::thread>);
void createThread(DerivedInterface& t)
{
    boost::shared_ptr<boost::thread> t1(new boost::thread(&DerivedInterface::run, &t)); 
    insert(t1);
}

Or, by using r-value references in C++11:

void insert(boost::thread&& t1);

void createThread(DerivedInterface& t)
{
    boost::thread t1(&DerivedInterface::run, &t); 
    insert(std::move(t1));
}

Alternatively, use boost::thread_group that does the above for you.