在线程安全类中返回一个Object

Question

I am having a problem that appears to indicate Java objects aren't created on the heap I expected. The short version is that I have a JMS onMessage() method that is calling another method to instantiate the proper object (routingCommand) based on the JSon payload of the TextMessage.

    public void onMessage(Message message) throws RuntimeException {

IRoutingCommand routingCommand = null;
routingCommand = instantiateRoutingCommand(message);
...
process(routingCommand);
}

private IRoutingCommand instantiateRoutingCommand(Message message)  {

    IRoutingCommand routingCommand = null;

    ... lots of code to build the correct type of RoutingCommand

    routingCommand = new IeRoutingCommand(ieNotification);
    return routingCommand;
}

The problem is that during my load test, on Extremely Rare occasions, the same JMS message is being "process()ed" multiple times. When I set maxConcurrentConsumers=1 this does not happen.

I found this gem of wisdom on the Internet that I never knew but assuming it is correct it would explain my problem:

Local references to objects are a bit different. The reference itself is not shared. The object referenced however, is not stored in each threads's local stack. All objects are stored in the shared heap.

The instantiateRoutingCommand method is the around 50 lines long - that's why I broke it out to begin with. I COULD examine the JMS message enough to figure out what type of object it represents and instantiate it in the onMessage() method and convert instantiateRoutingCommand to just use setters on the passed object. That would satisfy the above stipulation. But even that is not entirely trivial and would clutter up the onMessage() method.

I didn't try making the object volatile or making anything synchronized because if the above is true then I don't see any of that helping. So what's the best way to handle passing objects in a multi-threaded object?

Answer 1

You must either synchronize access to objects referenced by multiple threads or give each thread their own copy. While the later is potentially the only efficient solution, care should be taken that the copied object does not contain references also contained in the object being copied.

Answer 2

I ended up creating clone methods for all the subclasses of my RoutingCommand.

Then used that within a block synchronized on the class. Since the method that instantiates the correct subclass is just a parser (no I/O) it was not particularly onerous to block all the threads.

synchronized(FlowController.class) {
routingCommand = instantiateRoutingCommand(message).clone();  
}

This fixed my thread-safe problems. So the above point that returned objects are on shared heap is in fact true.