Home/ Questions/Q 603959
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-13T16:59:13+00:00

I’ve a class that internally uses a worker thread. Currently the ctor starts the

  • 0

I’ve a class that internally uses a worker thread. Currently the ctor starts the thread and the dtor stops (and waits for) it. Is this considered good code? I think it would be better to have separate start() / stop() functions for this purpose.

One of the problems is that stopping and waiting for the thread may throw exceptions, which is bad in a dtor.

What would you advice me:

  1. leave the code as it is and just catch and log exceptions in the dtor
  2. use start() / stop(), let the client handle exceptions and just delete the thread in the dtor (and issue a warning on unclean shutdown or something)
Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    I would probably not start the thread in the constructor, but rather have a start function. If the worker thread is basically invisible to the user then it might make little difference, and starting in the constructor might be better. But if the user interacts with the worker thread in any way (e.g. their code is run in it), then eventually someone will need to set up some state after the object is created, but before the thread runs. Murphy’s Law guarantees it 😉

    I would stop it in the destructor, and catch and log the exception. If the user is likely to need to know the result of stopping (for instance if failure means that the worker thread might not have done its work), then also have a stop function which they can optionally call in order to get that information.

    Btw, there are also some technical concerns to do with starting a thread in a constructor at all. The new thread will potentially run before the constructor returns in the old thread. If it accesses its owner object (for example to report the result), it can therefore access an incompletely-constructed object. That’s usually easy to work around, right up to the point where you inherit from your original class. Now the thread is started before the derived class constructor runs, which could cause all kinds of trouble. So if you do start a thread in a constructor, and the thread can access the object directly or indirectly, take care and leave lots of warnings.

    • 0