Is the process thread safe?

Question

In my recent interview by explaining a situation they asked if the process is thread-safe

There are two synchronized methods one is static and other is not static i.e., non-static Method A and static Method B. These two methods access a shared data.

Now thread A calls non-static method A and thread B is calls static method B. Is this thread safe and explain y?

Answer 1

No, it's not thread-safe. For it to be thread-safe the different threads have to access the shared data using the same lock, but the two methods use different locks. Putting synchronized on a static method uses the class as a lock, putting synchronized on an instance method uses the object as a lock.

If the threads use different locks then neither thread is blocked, and both can access or modify the data concurrently. Even if the threads are only accessing data, and neither modifies it, locking would assure memory visibility. Without the shared lock you can't rely on that visibility. Unrestricted concurrent access would be safe only if the data is immutable and is already safely published.

Assuming the shared data has to be mutable, the fix would be for both methods to use the same lock. You can always specify your own lock if you use a synchronized block (rather than adding synchronized to the method), so the instance method could use:

public void yourInstanceMethod() {
    synchronized(WhateverYourClassIs.class) {
        // code accessing shared data
    }
}