Possibility of deadlock with two locks?

Question

Can this code deadlock with thread 1 calling one and thread 2 calling two. That is, can the acquisition of the inner lock be reordered to before the acquisition of the outer one (from the POV of the other thread)?

private final Object foo = new Object();
synchronized  void one() {
    // ...
    synchronized(this.foo) {
       // ...
    }
    // ...
}

synchronized void two() {
    // ...
    synchronized(this.foo) {
       // ...
    }
    // ...
}

@AndyTurner One intrinsic lock on `this`, one intrinsic lock on `this.foo` — Michael, Aug 07 '19 at 15:45
@michalk I also don't think so -- I think the acquire semantics on the `this` lock prevents operations from being reordered to before it, but I can't reason with the terms in the spec. — Artefacto, Aug 07 '19 at 15:46
The original code uses actual `java.util.concurrent.lock.Lock`s, but I think this example is equivalent. — Artefacto, Aug 07 '19 at 15:48
The problem might be that between calls to those functions `this.foo` might point to different object - then you have a problem. — Michał Krzywański, Aug 07 '19 at 15:49
@michalk Indeed https://stackoverflow.com/questions/6910807/synchronization-of-non-final-field — Michael, Aug 07 '19 at 15:50
@SolomonSlow the functions are obviously not identical. They will do different things before, during and after the inner `synchronized` block. — Artefacto, Aug 07 '19 at 15:54
Sorry!, my eyes skipped over the `foo = new Object()` assignment. My previous comments are invalid because of that. — Solomon Slow, Aug 07 '19 at 15:56

score 0 · Answer 1 · answered Aug 07 '19 at 15:45

No, this will not deadlock.

When synchronized methods are called the intrinsic lock of this is locked before the method’s body is executed. Here either thread 1 or thread 2 will get to run its method, and the other one will not be able to lock on the intrinsic lock of this.foo so the owner of the lock of this will be able to lock this.foo.

score 0 · Answer 2 · answered Aug 07 '19 at 16:06

So for with a Simple Test :

class LockTest implements Runnable {
    public final Object foo = new Object();
    boolean runOne;

    public LockTest(boolean runOne) {
        this.runOne = runOne;
    }

    synchronized void  one() {
        System.out.println("runnin one function");
        synchronized(this.foo) {
            try {
                System.out.println("Enter Sleep function one");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    synchronized void  two() {
        System.out.println("running two function");
        synchronized(this.foo) {
            try {
                System.out.println("enter sleep function two");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public void run() {
        if(runOne)
        one();
        else
            two();
    }
}

With this in a Main class :

while (true)
        {
            LockTest document2 = new LockTest(true);
            LockTest document3 = new LockTest(false);
            Thread tread1 = new Thread(document2);
            Thread tread2 = new Thread(document3);
            tread1.start();
            tread2.start();
            a++;
            if(a==10)
                break;

        }

We are not locking and even watching with a Thread Dump everything is working Fine. Why? Because every time we are initializating a new Thread with a new object foo. But if that object is declared as static it will be a lock and the others threads need to wait. So from my test and POV. No, it can't be deadlocked.

Possibility of deadlock with two locks?

2 Answers2