Thread safety when multiple threads accessing the same method in Java

Question

I have a method like this

private handleObj(Obj obj)
{
    String data = obj.getData;
    String key = obj.getKey;

    store(key, data);
}

If this method is called by multiple threads at the same time, will the value of data be shared across multiple threads?

Like if thread A calls this method by handleString(objFromThreadA) then thread B calls this method by handleString(objFromThreadB). Would there be any chance that value of String data in thread A was replaced by value of String data in thread B?

----- Edit 1 -----

I am a bit confused about thread safety here. The method below is a callback from a lib that I am using for MQTT client.

/**
     * This method is called when a message arrives from the server.
     *
     * <p>
     * This method is invoked synchronously by the MQTT client. An
     * acknowledgment is not sent back to the server until this
     * method returns cleanly.</p>
     * <p>
     * If an implementation of this method throws an <code>Exception</code>, then the
     * client will be shut down.  When the client is next re-connected, any QoS
     * 1 or 2 messages will be redelivered by the server.</p>
     * <p>
     * Any additional messages which arrive while an
     * implementation of this method is running, will build up in memory, and
     * will then back up on the network.</p>
     * <p>
     * If an application needs to persist data, then it
     * should ensure the data is persisted prior to returning from this method, as
     * after returning from this method, the message is considered to have been
     * delivered, and will not be reproducible.</p>
     * <p>
     * It is possible to send a new message within an implementation of this callback
     * (for example, a response to this message), but the implementation must not
     * disconnect the client, as it will be impossible to send an acknowledgment for
     * the message being processed, and a deadlock will occur.</p>
     *
     * @param topic name of the topic on the message was published to
     * @param message the actual message.
     * @throws Exception if a terminal error has occurred, and the client should be
     * shut down.
     */
    public void messageArrived(String topic, MqttMessage message) throws Exception;

Every time this method is called. I create a new thread to handle the message object, which is I am getting a lot of data and keys from message object. As I read the comments, it says that this method is called synchronously, so does that mean message is sure to be thread safe?

Here's how I handle the message object.

@Override
public void messageArrived(String topic, MqttMessage message) throws Exception
{
    Runnable runnable = new Runnable() 
    {   
        @Override
        public void run() 
        {
            try 
            {
                handleMessage(topic, new String(message.getPayload()));
            } 

            catch (Exception e) 
            {
                e.printStackTrace();
            }
        }
    };

    threadPool.execute(runnable);
}

And within handleMessage(String topic, String message) I have something like this:

private void handleMessage(String topic, String message)
{
    JSONObject messageJson = new JSONObject(message);

    //get values from JSON
    String value = messageJson.get("key");
}

So, I am not sure if what I am doing here is thread safe. If I am passing a newly allocated String ( new String(message.getPayload()) ) to my handleMessage method, does that mean the new String is placed on stack of one thread, and no other threads can share that string?

Answer 1

Every method invocation is a method in its own scope.

You don't need threads to make it visible - just use a recursive method, to make this clear:

void middle (String s) {
    println ("<" + s);
    if (s.length () > 2) 
        middle (s.substring (1, s.length () - 1));
    println (s + ">");
}

In line 4, a new instance of the method is called, and s is now a truncated version of the outer s. But on completion of the inner call, the outer s is not affected at all.

-> middle ("foobar")
<foobar
<ooba
<ob
ob>
ooba>
foobar>

With threads, the possible collision (better: impossible collision) is only harder to show.

But the question is legitim. See, how, at first glance, equivalent code, behaves in bash (for me, very surprisingly):

middle () {
  s=$1
  echo "< $s"
  len=${#s}
  if (( $len > 2 ))
  then
      middle ${s:1:((len-2))}
  fi
  echo "$s >"
}

middle "foobar"

< foobar
< ooba
< ob
ob >
ob >
ob >