boost-thread

My application has a section that resembles the following code void SomeClass::OtherMethod(std::vector<std::string>& g) { g.pushback("Something"); } void SomeClass::SomeMethod() { std::vector<std::string> v; boost::thread t(boost::bind(&SomeClass::OtherMethod,this,v) t.join(); std::cout << v[0]; //Why is this empty when the vector created on stack } I wanted to know why the vector v is empty when the vector is created on the stack and it works when it is created on the heap. I was expecting the above code to work since the vector remains in scope even when it is created on the stack. Bind

In my applications, I generally want to intercept SIGINT and SIGTERM signals in order to close down gracefully. In order to prevent worker threads from "stealing" signals, I do this in the entrypoint for each: // Block signals in this thread sigset_t signal_set; sigaddset(&signal_set, SIGINT); sigaddset(&signal_set, SIGTERM); sigaddset(&signal_set, SIGHUP); sigaddset(&signal_set, SIGPIPE); pthread_sigmask(SIG_BLOCK, &signal_set, NULL); If I don't, when I perform Ctrl + C , some of the time (it's unspecified as to which thread will get the signal) my handlers in the base thread won't be invoked

Some C++ objects have no copy constructor, but have move constructor. For example, boost::promise. How can I bind those objects using their move constructors ? #include <boost/thread.hpp> void fullfil_1(boost::promise<int>& prom, int x) { prom.set_value(x); } boost::function<void()> get_functor() { // boost::promise is not copyable, but movable boost::promise<int> pi; // compilation error boost::function<void()> f_set_one = boost::bind(&fullfil_1, pi, 1); // compilation error as well boost::function<void()> f_set_one = boost::bind(&fullfil_1, std::move(pi), 1); // PS. I know, it is possible to

I am currently working on a small wrapper class for boost thread but I dont really get how the sleep function works, this is what I have got so far: BaseThread::BaseThread(){ thread = boost::thread(); bIsActive = true; } BaseThread::~BaseThread(){ join(); } void BaseThread::join(){ thread.join(); } void BaseThread::sleep(uint32 _msecs){ if(bIsActive) boost::this_thread::sleep(boost::posix_time::milliseconds(_msecs)); } This is how I implemented it so far but I dont really understand how the static this_thread::sleep method knows which thread to sleep if for example multiple instances of my

I have a fairly complex multi threaded application (server) that from time to time will crash due to an assert: /usr/include/boost/smart_ptr/shared_ptr.hpp:418: T* boost::shared_ptr< <template-parameter-1-1> >::operator->() const [with T = msg::Player]: Assertion `px != 0' failed. I have been unable to pinpoint the cause and was wondering if this is a problem with boost::shared_ptr or it is me? I tried g++ 4.4.3-4ubuntu5 and llvm-g++ (GCC) 4.2.1 with optimization and without optimization and libboost1.40-dev (= 1.40.0-4ubuntu4). There should be no problem with using boost::shared_ptr as long

I've got several long running boost threads that I want to be able to shut down by interrupting them. All of the documentation I can find says that you can catch the thread_interrupted exception, but it doesn't really say what happens if you don't. I would assume it kills the thread (and hopefully the thread gets properly cleaned up). But then does the exception die off with the thread? Or does it get passed up to the main thread and kill it too? The exception is just like any other C++ exception. If you choose not to catch it, it will cause the same effect as any other unhandled exception. If

( This question , though similar, didn't really answer my question.) I've had problems with my own "thread group" implementation , and being no closer to solving or even identifying the issue, I'm looking into just using boost::thread_grp . Now, from what documentation I can find on the subject 1 , I've always believed that thread objects — no matter the duration of their actual work — remain alive and a part of a thread group until the thread group is destroyed. However, a cursory test seems to indicate that boost::thread_group::size() decreases on its own as threads do their work and