How to call destructor on thread object?
I'm using the boost meta state machine and upon entry of this state, I create two threads, and stop these threads in the on_exit(). In on_entry(), I call the functors of each class and create threads and add those to a boost thread_group. What I need to do now is call the destructor of the objects on the threads ( of ClassA and ClassB) within on_exit(). I'm unclear as to how the destructors of the objects would/should be called when interrupting the threads. The destructors are currently not being called. struct MyEvent : public msm::front::state<> { template <class Event, class FSM> void on_entry(Event const&, FSM&); template <class Event, class FSM> void on_exit(Event const&, FSM&); boost::thread_group threads; }; template <class Event, class FSM> void psm_::MyEvent::on_entry(Event const& ev, FSM& sm) { auto bb = std::make_shared<bounded_buffer<MyData> >(100); ClassA<bounded_buffer<MyData> > c_a(bb); ClassB<bounded_buffer<MyData> > c_b(bb); threads.add_thread(new boost::thread(c_a)); threads.add_thread(new boost::thread(c_b)); } template <class Event, class FSM> void psm_::MyEvent::on_exit(Event const& ev, FSM& sm) { threads.interrupt_all(); threads.join_all(); } template <class Buffer> class ClassB { private: typedef typename Buffer::value_type value_type; shared_ptr<Buffer> m_container; public: ClassB(shared_ptr<Buffer> buffer) : m_container(buffer) { } ~ClassB() { // ... } void operator()() { try { // ... do stuff boost::this_thread::interruption_point(); } catch(const boost::thread_interrupted&) { // ... } } }
On 19/05/2015 15:26, Lane wrote:
I'm using the boost meta state machine and upon entry of this state, I create two threads, and stop these threads in the on_exit().
In on_entry(), I call the functors of each class and create threads and add those to a boost thread_group. What I need to do now is call the destructor of the objects on the threads ( of ClassA and ClassB) within on_exit(). I'm unclear as to how the destructors of the objects would/should be called when interrupting the threads. The destructors are currently not being called.
Since you are passing a copy of the object as the thread's state, the destructor for the local instances will be called in on_entry(), and the destructor for the instances owned by the thread will be called when the thread_group is destroyed, which is when MyEvent is destroyed. I'm not really familiar enough with Boost.MSM to know whether the event instance is destroyed when the event is handled (which if this were the case, you shouldn't be keeping threads in it), or when the containing state machine is destroyed, or only when the program exits.
Mere moments ago, quoth I:
On 19/05/2015 15:26, Lane wrote:
I'm using the boost meta state machine and upon entry of this state, I create two threads, and stop these threads in the on_exit().
In on_entry(), I call the functors of each class and create threads and add those to a boost thread_group. What I need to do now is call the destructor of the objects on the threads ( of ClassA and ClassB) within on_exit(). I'm unclear as to how the destructors of the objects would/should be called when interrupting the threads. The destructors are currently not being called.
Since you are passing a copy of the object as the thread's state, the destructor for the local instances will be called in on_entry(), and the destructor for the instances owned by the thread will be called when the thread_group is destroyed, which is when MyEvent is destroyed.
I'm not really familiar enough with Boost.MSM to know whether the event instance is destroyed when the event is handled (which if this were the case, you shouldn't be keeping threads in it), or when the containing state machine is destroyed, or only when the program exits.
Sorry, pressed Send too quickly. If you want to destroy the threads in on_exit instead, then since thread_group lacks a means to remove a thread (unless you still have a reference to it), you will have to destroy the thread_group instead. The simplest way to do that is to wrap it in a std::unique_ptr and reset() it in on_exit.
Thanks for the explanation, that helps. But what I'm looking to do is find a way to call the destructor on the thread object. The ClassA and classB objects are connected to a USB device and I need to find a way to properly shut them down before destroying the threads in on_exit(). Any thoughts? On Tue, May 19, 2015 at 12:49 AM, Gavin Lambert <gavinl@compacsort.com> wrote:
Mere moments ago, quoth I:
On 19/05/2015 15:26, Lane wrote:
I'm using the boost meta state machine and upon entry of this state, I create two threads, and stop these threads in the on_exit().
In on_entry(), I call the functors of each class and create threads and add those to a boost thread_group. What I need to do now is call the destructor of the objects on the threads ( of ClassA and ClassB) within on_exit(). I'm unclear as to how the destructors of the objects would/should be called when interrupting the threads. The destructors are currently not being called.
Since you are passing a copy of the object as the thread's state, the destructor for the local instances will be called in on_entry(), and the destructor for the instances owned by the thread will be called when the thread_group is destroyed, which is when MyEvent is destroyed.
I'm not really familiar enough with Boost.MSM to know whether the event instance is destroyed when the event is handled (which if this were the case, you shouldn't be keeping threads in it), or when the containing state machine is destroyed, or only when the program exits.
Sorry, pressed Send too quickly.
If you want to destroy the threads in on_exit instead, then since thread_group lacks a means to remove a thread (unless you still have a reference to it), you will have to destroy the thread_group instead.
The simplest way to do that is to wrap it in a std::unique_ptr and reset() it in on_exit.
_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users
On Tue, May 19, 2015 at 4:40 PM, Lane <software.research.development@gmail.com> wrote:
Thanks for the explanation, that helps. But what I'm looking to do is find a way to call the destructor on the thread object. The ClassA and classB objects are connected to a USB device and I need to find a way to properly shut them down before destroying the threads in on_exit(). Any thoughts?
It sounds like an obvious response, but, "when it goes out of scope"? So there must be some instance, reference, pointer (if dynamically allocated, shared pointer, etc), holding onto it?
On Tue, May 19, 2015 at 12:49 AM, Gavin Lambert <gavinl@compacsort.com> wrote:
Mere moments ago, quoth I:
On 19/05/2015 15:26, Lane wrote:
I'm using the boost meta state machine and upon entry of this state, I create two threads, and stop these threads in the on_exit().
In on_entry(), I call the functors of each class and create threads and add those to a boost thread_group. What I need to do now is call the destructor of the objects on the threads ( of ClassA and ClassB) within on_exit(). I'm unclear as to how the destructors of the objects would/should be called when interrupting the threads. The destructors are currently not being called.
Since you are passing a copy of the object as the thread's state, the destructor for the local instances will be called in on_entry(), and the destructor for the instances owned by the thread will be called when the thread_group is destroyed, which is when MyEvent is destroyed.
I'm not really familiar enough with Boost.MSM to know whether the event instance is destroyed when the event is handled (which if this were the case, you shouldn't be keeping threads in it), or when the containing state machine is destroyed, or only when the program exits.
Sorry, pressed Send too quickly.
If you want to destroy the threads in on_exit instead, then since thread_group lacks a means to remove a thread (unless you still have a reference to it), you will have to destroy the thread_group instead.
The simplest way to do that is to wrap it in a std::unique_ptr and reset() it in on_exit.
_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users
_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users
On 20/05/2015 08:40, Lane wrote:
Thanks for the explanation, that helps. But what I'm looking to do is find a way to call the destructor on the thread object. The ClassA and classB objects are connected to a USB device and I need to find a way to properly shut them down before destroying the threads in on_exit(). Any thoughts?
I covered that in my second reply. After joining the threads, you have to destroy the thread_group. But first you must make it destroyable, by putting it in a unique_ptr.
I know you did, and thats still one path I'm following, but I'm having a hard time trying to understand how to wrap it in the way I currently have it written. If you have the time, please post. On Tue, May 19, 2015 at 7:29 PM, Gavin Lambert <gavinl@compacsort.com> wrote:
On 20/05/2015 08:40, Lane wrote:
Thanks for the explanation, that helps. But what I'm looking to do is find a way to call the destructor on the thread object. The ClassA and classB objects are connected to a USB device and I need to find a way to properly shut them down before destroying the threads in on_exit(). Any thoughts?
I covered that in my second reply. After joining the threads, you have to destroy the thread_group. But first you must make it destroyable, by putting it in a unique_ptr.
_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users
Here's a bit more detail of my current problem. I have implemented destructors within ClassA and ClassB. When adding this thread to the thread_group, the thread objects destructors are being called as soon as they're added to the thread_group. struct MyStruct : ... { boost::thread_group threads; }; template <class Event, class FSM> void psm_::MyEvent::on_entry(Event const& ev, FSM& sm) { auto bb = std::make_shared<bounded_buffer<MyData>>(100); ClassA<bounded_buffer<MyData>> c_a(bb); ClassB<bounded_buffer<MyData>> c_b(bb); threads.add_thread(new boost::thread(c_a); // destructors called here threads.add_thread(new boost::thread(c_b); } I've wrapped the thread_group within unique_ptr so that I can call reset, but I don't even make it to this point because the thread objects have already been destroyed when being added to the thread (and program exits). template <class Event, class FSM> void psm_::MyEvent::on_exit(Event const& ev, FSM& sm) { std::unique_ptr<boost::thread_group> tg(&threads); tg.reset(); threads.interrupt_all(); threads.join_all(); } And if I don't add the destructors to the thread objects (ClassA, ClassB), I am able to reach on_exit when I need to. Any thoughts as to why the destructors (which I need to make use of in on_exit) are being called when adding the new threads? On Wed, May 20, 2015 at 1:47 PM, Lane < software.research.development@gmail.com> wrote:
I know you did, and thats still one path I'm following, but I'm having a hard time trying to understand how to wrap it in the way I currently have it written. If you have the time, please post.
On Tue, May 19, 2015 at 7:29 PM, Gavin Lambert <gavinl@compacsort.com> wrote:
On 20/05/2015 08:40, Lane wrote:
Thanks for the explanation, that helps. But what I'm looking to do is find a way to call the destructor on the thread object. The ClassA and classB objects are connected to a USB device and I need to find a way to properly shut them down before destroying the threads in on_exit(). Any thoughts?
I covered that in my second reply. After joining the threads, you have to destroy the thread_group. But first you must make it destroyable, by putting it in a unique_ptr.
_______________________________________________ Boost-users mailing list Boost-users@lists.boost.org http://lists.boost.org/mailman/listinfo.cgi/boost-users
On 21/05/2015 12:12, Lane wrote:
Here's a bit more detail of my current problem.
I have implemented destructors within ClassA and ClassB. When adding this thread to the thread_group, the thread objects destructors are being called as soon as they're added to the thread_group.
struct MyStruct : ... { boost::thread_group threads; };
template <class Event, class FSM> void psm_::MyEvent::on_entry(Event const& ev, FSM& sm) { auto bb = std::make_shared<bounded_buffer<MyData>>(100);
ClassA<bounded_buffer<MyData>> c_a(bb); ClassB<bounded_buffer<MyData>> c_b(bb);
threads.add_thread(new boost::thread(c_a); // destructors called here threads.add_thread(new boost::thread(c_b); }
No, what's happening there is that the c_a and c_b temporary objects are being *copied* to the thread, and then the *originals* are being destroyed. The copies owned by the thread remain undestroyed.
I've wrapped the thread_group within unique_ptr so that I can call reset, but I don't even make it to this point because the thread objects have already been destroyed when being added to the thread (and program exits).
template <class Event, class FSM> void psm_::MyEvent::on_exit(Event const& ev, FSM& sm) { std::unique_ptr<boost::thread_group> tg(&threads); tg.reset();
threads.interrupt_all(); threads.join_all(); }
I'm sorry, but you clearly need to go back to school and learn how pointers work. (And then go back and re-read my earlier post. It's the one in MyStruct that has to be a unique_ptr and you're doing it in the wrong order.)
participants (1)
-
Gavin Lambert -
Lane -
Michael Powell