Synchronization concerns with a static method in java

Suppose I have a Utility class,

public class Utility {

    private Utility() {} //Don't worry, just doing this as guarantee.

    public static int stringToInt(String s) {
        return Integer.parseInt(s);
    }
};

Now, suppose, in a multithreaded application, a thread calls, Utility.stringToInt() method and while the operation enters the method call, another thread calls the same method passing a different s. What happens in this case? Does Java loc开发者_StackOverflow社区k a static method?

There is no issue here. Each thread will use its own stack so there is no point of collision among different s. And Integer.parseInt() is thread safe as it only uses local variables.

Java does not lock a static method, unless you add the keyword synchronized.

Note that when you lock a static method, you grab the Mutex of the Class object the method is implemented under, so synchronizing on a static method will prevent other threads from entering any of the other "synchronized" static methods.

Now, in your example, you don't need to synchronize in this particular case. That is because parameters are passed by copy; so, multiple calls to the static method will result in multiple copies of the parameters, each in their own stack frame. Likewise, simultaneous calls to Integer.parseInt(s) will each create their own stack frame, with copies of s's value passed into the separate stack frames.

Now if Integer.parseInt(...) was implemented in a very bad way (it used static non-final members during a parseInt's execution; then there would be a large cause for concern. Fortunately, the implementers of the Java libraries are better programmers than that.

In the example you gave, there is no shared data between threads AND there is no data which is modified. (You would have to have both for there to be a threading issue)

You can write

public enum Utility {
    ; // no instances

    public synchronized static int stringToInt(String s) {
        // does something which needs to be synchronised.
    }
}

this is effectively the same as

public enum Utility {
    ; // no instances

    public static int stringToInt(String s) {
        synchronized(Utility.class) {
            // does something which needs to be synchronised.
        }
    }
}

however, it won't mark the method as synchronized for you and you don't need synchronisation unless you are accessing shared data which can be modified.

It should not unless specified explicitly. Further in this case, there wont be any thread safety issue since "s" is immutable and also local to the method.

You dont need synchronization here as the variable s is local.

You need to worry only if multiple threads share resources, for e.g. if s was static field, then you have to think about multi-threading.