thread safety with two synchronized methods, one static, one non static

In Java, the following:

public class MyClass { public synchronized void nonStaticMethod() { // code } public synchronized static void staticMethod() { // code } } 

is equivalent to the following:

public class MyClass { public void nonStaticMethod() { synchronized(this) { // code } } public void static staticMethod() { synchronized(MyClass.class) { // code } } } 

As you see, static methods use this as monitor object, and non-static methods use class object as monitor.

As this and MyClass.class are different objects, static and non-static methods may run concurrently.

To "fix" this, create a dedicated static monitor object and use it in both static and non-static methods:

public class MyClass { private static Object monitor = new Object(); public void nonStaticMethod() { synchronized(monitor) { // code } } public static void staticMethod() { synchronized(monitor) { // code } } } 

What if one of the methods is static and one non static? Is it still thread safe, or bad things can happen if multiple threads call the methods?

Bad things can happen.

The static method will lock on the class monitor. The instance method will lock on the instance monitor. Since two different lock objects are in use, both methods could execute at the same time from different threads. If they share state (i.e. the instance method accesses static data) you will have problems.

What if one of the methods is static and one non static? Is it still thread safe, or bad things can happen if multiple threads call the methods?

Synchronization works with monitor (locks) that is taken on object.

In case of static method it's object of Class's class and in case of instance method it's this or calling object.

Since both the objects are different hence both synchronized static and non-static method will not block each other in case of multi-threading. Both the methods will execute simultaneously.

What if one of the methods is static and one non static

Yes.. Bad things can happen. Because if you synchronize on a static method, then you will be locking on the monitor of the Class object not on the class instancei.e, you will be locking on MyClass.class. Whereas when you are synchronizing on an instance (non-static) method, you will actually be locking on the current instance i.e, this . So, you are locking on two different objects. So, the behaviour will be undefined and certainly not correct.

PS : In multi-threading, as a rule of thumb, please remember - If bad things can happen, they will happen.

What if ... Is it still thread safe?

Can't answer that question without a complete example. The question of thread safety is never a question about methods: It's a question about corruption of data structures and about liveness guarantees. Nobody can say whether a program is thread safe without knowing what all of the different threads do, what data they do it to, and how they coordinate (synchronize) with one another.