Question

Is it safe to start a thread pool in an objects constructor? I know that you shouldn’t start a thread from a constructor, something about the “this” pointer escaping (I don’t exactly understand this, but will do some more searches to try and figure it out).

The code would look something like this:

private ExecutorService pool;

public handler()
{
  pool = Executors.newCachedThreadPool();
}

public void queueInstructionSet(InstructionSet set)
{
  pool.submit(new Runnable that handles this instruction set);
}

If that doesn’t work, i could just create this class as a Runnable and start it in a new thread. However, that seems like it would be adding an unnecessary thread to the program where it doesn’t really need one.

Thanks.

EDIT:

Thanks for the replies everyone, they definitely helped make sense of this.

As per the code, in my mind it makes sense that this constructor creates the thread pool, but let me explain what specifically this code is doing, because i may be thinking about this in a weird way.

The entire point of this object is to take “Instruction Sets” objects, and act on them accordingly. The instruction sets come from clients connected to a server. Once a full instruction set is received from a client, that instruction set is sent to this object (handler) for processing.

This handler object contains a reference to every object that an instruction set can act upon. It will submit the instruction set to a thread pool, which will find which object this instruction set wants to interact with, and then handle the instruction set on that object.

I could handle the instruction set object in the IO server, but my thoughts are having a separate class for it makes the entire code more readable, as each class is focusing on doing only one specific thing.

Thoughts? Advice?

Thanks

Answer 1

Your sample code doesn’t let “this” escape at all. It’s reasonably safe to start a new thread in a constructor (and even use this as the Runnable, which you don’t in this example) so long as you’re sure that you’ve already initialized the object as far as the new thread will need it. For example, setting a final field which the new thread will rely on after starting the thread would be a really bad idea 🙂

Basically letting the “this” reference escape is generally nasty, but not universally so. There are situations in which it’s safe. Just be careful.

Having said that, making a constructor start a thread might be seen as doing too much within the constructor. It’s hard to say whether it’s appropriate in this case or not – we don’t know enough about what your code is doing.

EDIT: Yup, having read the extra information, I think this is okay. You should probably have a method to shut down the thread pool as well.