Nested synchronized blocks on multiple objects without deadlock

Question

Is it possible? Here is an example problem that exhibits deadlock:
public class SomeObject {
     public static class Foo {
          private int n = 0;
          public synchronized void p() {
               n++;
               if (n % 100 == 0)
                    System.out.print("f");
     public static class Bar {
          private int n = 0;
          public void p() {
               n++;
               if (n % 100 == 0)
                    System.out.print("b");
     public void doSomething1(Foo f, Bar b) {
          synchronized(f) {
               synchronized(b) {
                    f.p();
                    b.p();
     public void doSomething2(Foo f, Bar b) {
          synchronized(b) {
               synchronized(f) {
                    b.p();
                    f.p();
     public static void main(String[] args) {
          SomeObject so = new SomeObject();
          Foo f = new Foo();
          Bar b = new Bar();
          for (int i = 0; i < 100; i++)
               (new MyThread(so, f, b)).start();
     public static class MyThread extends Thread {
          SomeObject so = null;
          Foo f = null;
          Bar b = null;
          public MyThread(SomeObject so, Foo f, Bar b) {
               this.so = so;
               this.f = f;
               this.b = b;
          public void run() {
               while (true) {
                    if (Math.random() > 0.5)
                         so.doSomething1(f, b);
                    else
                         so.doSomething2(f, b);
}

Answer 1

Well, playing with sinchronized code as to be done carefully.
This is very important because de JVM does not break the deadlocks (like by throwing an exception in a deadlocked thread). so in the above example, once 2 of the threads do deadlock, the rest of the threads that are created in the main method loop will deadlock too.
For that it is better to:
a) use minimal sinchronized code, like in Foo.p, the method is sinchronized to have access to an internal variable.
b) use layered sinchronization. If several components in a system have synchronized code (methods) or are used as monitors in synchronized blocks, then it is better to layer the monitor usage nesting and to eliminate circular dependencies (also it is good to minimize dependencies). This is similar to code dependency in which package circular dependency should be avoided. Though in this case it is critical.
In the example given, the doSomething* methods generate circular dependency of monitors.
If the desing is to have a 'transaction' in calling Foo.p() and Bar.p() from the doSomething* methods, then the usage of a 'grand-daddy' central lock would be a simple solution, like changing the doSomething* methods to:
static public synchornized void doSomething*(Foo f, Bar b) {
f.p();
b.p();
or
public void doSomething*(Foo f, Bar b) {
synchornized (SomeObject.class) {
f.p();
b.p();
If there is no need of a 'transaction' in the calling of Foo.p() and Bar.p(), then the doSomething* methods should not have any type of synchronization, and the methods Foo.p() and Bar.p() should both be synchronized.
Also a more complex scheme could be deviced in order to lower the contention on the SomeObject class monitor. Though for the example given, as it exists only one instance of both Foo and Bar, it is not needed.
llongeri