Is it safe to use a static object in a non-static method when multiple threads are accessing it?

Question

My class looks something like this:

public Class A {

     private static final ObjectMapper mapper = new ObjectMapper();

     public String get(String key) {
          JsonNode nod = mapper.readTree(getFromCache(key));
     }
}

Multiple threads would be accessing this method. Do I need to synchronize it? Do I need to move the mapper inside the method?

Answer 1

This depends on the implementation of ObjectMapper. For a possible answer, see: Should I declare Jackson's ObjectMapper as a static field?

It is not possible to tell from the code sample you have provided because we don't know what that ObjectMapper is.

To find the answer you would need to check the javadoc of ObjectMapper. Or failing that, the implementation.

If you are unsure, you could:

• create a new ObjectMapper inside the method so there is a new object each time,
• create a ThreadLocal, so each thread has it's own object

Creating objects is very cheap on the JVM (unless they do expensive operations like scanning the class path, etc).

Answer 2

There is one copy of static variable per class-loader that loaded this class. This more-or-less means per-process, however you need to be aware of the difference.

E.g. when two web-apps have the same class bundled, the class will be loaded twice, thus having two copies of the same static field.

If you need a variable having independent value on a thread basis, have a look at ThreadLocal

Answer 3

As WW. mentioned it is dependent upon the ObjectMapper.readTree implementation. There are multiple factors which decides whether the method is thread safe or not.

Like :

1. Whether the method is synchronized or not
2. Does method uses variables which are declared outside the method