C++ 指向boost:：thread的指针_C++_Boost Thread

C++ 指向boost:：thread的指针

c++

C++ 指向boost:：thread的指针,c++,boost-thread,C++,Boost Thread,我有一个关于线程管理的问题我的问题是，我想创建一个类ThreadManager，它必须管理所有创建的线程，当然还要销毁这个线程 class DerivedInterface { public: DerivedInterface():id("Test"){}; virtual ~DerivedInterface(){}; virtual void run() = 0; virtual std::string getId() = 0; const std::

我有一个关于线程管理的问题

我的问题是，我想创建一个类ThreadManager，它必须管理所有创建的线程，当然还要销毁这个线程

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

     }

boost:：thread的指针不是null，那么会发生什么呢？先谢谢你

为什么我不能做这样的事

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

在上面的

t1

中，在堆栈上创建对象，然后将指向

t1

的指针插入到映射中，然后

t1

超出范围并被销毁，因此指向它的所有现有指针都变为无效

您可以通过传递

shared_ptr

而不是

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

或者，使用它为您完成上述操作