方法调用与同步块之间的“差距” —避免并发死锁

Question

The following method is a method of class SomeType -- the type it is taking as its argument. The line comments indicate the line #s.

synchronized void someMethod(SomeType other) {  // line 1
                                // line 2
    synchronized (other) {      // line 3
        //...do stuff           // line 4
    }
}

The block indicated as "line 4" has calls to some other synchronized methods of both this and other , and this code is intended for avoiding deadlocks.

However -- suppose both a.someMethod(b) and b.someMethod(a) are invoked concurrently, where a and b are different instances.

Further suppose that b.someMethod(a) is invoked right after a.someMethod(b) is, and they both are held up at line 2-- each of a and b acquired its own lock and waiting for the other's lock to proceed.

Can/not this happen?

If so - on which jdk implementations? This looks like something that depends on the specific implementation unless it is explicitly in the jdk specifications.

TIA

Answer 1

Yes, the deadlock you describe can happen. How often it happens may be dependent on the specifics of the threading code; these days, you are most likely using the native threading of the operating system, so it would be more dependent on the native OS than on the JDK/JRE. Deadlock is likely possible on most platforms, though, so you should guard against it in your code.

If you think contention for the method will be low or if you don't care about performance, you could synchronize on a static member or on the class itself, rather than synchronizing on the objects. If you do care about performance and think contention will be significant, you will need to figure out a way to ensure that the monitors are locked in the same order independent of which object the method is being called on and which is the method argument.