Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Java: Nested synchronization blocks

I saw this in one of Heinz Kabutz's Java Specialist newsletter editions and, although the rest (and indeed, all) of Dr. Kabutz's articles are well-explained and detailed, he seemed to gloss over what this code is doing, or more importantly, what it's significance is:

public class SomeObject {
    private Object lock1;
    private Object lock2;

    public void doSomething() {
        synchronized(lock1) {
            synchronized(lock2) {
                // ...
            }
        }
    }
}

What are the implications of nesting synchronized blocks? How does this affect different threads attempting to doSomething()?

like image 918
IAmYourFaja Avatar asked Apr 28 '12 15:04

IAmYourFaja


People also ask

Can synchronized block be nested?

public void doSomething() { synchronized(lock1) { synchronized(lock2) { // ... } } } public void doOtherthing() { synchronized(lock2) { synchronized(lock1) { // ... } } } now if more than one thread are trying to access these methods then there may be a deadlock because of nested synchronized blocks.

What is Java synchronization block?

A Synchronized block is a piece of code that can be used to perform synchronization on any specific resource of the method. A Synchronized block is used to lock an object for any shared resource and the scope of a synchronized block is smaller than the synchronized method.

What is nested monitor lockout?

Nested monitor lockout is a problem similar to deadlock. A nested monitor lockout occurs like this: Thread 1 synchronizes on A Thread 1 synchronizes on B (while synchronized on A) Thread 1 decides to wait for a signal from another thread before continuing Thread 1 calls B.


2 Answers

There are 2 possible issues that one would have to watch out for

  1. Nested locks can result in deadlocks quite easily if one is using wait/notify. Here is an explanation of why. http://tutorials.jenkov.com/java-concurrency/nested-monitor-lockout.html

  2. One should be wary that if another method wishes to lock the same two objects, they must always do it in the same order, otherwise there is the possibility of another deadlock situation as explained in this post: How to avoid Nested synchronization and the resulting deadlock

like image 141
Bruce Lowe Avatar answered Sep 20 '22 08:09

Bruce Lowe


On its own this code snippet won't cause any problem. But the problem may come in the form of deadlock if there is something like this code; where we have two methods with synchronized blocks in such a way that objects are locked in opposite orders-

public void doSomething() {
    synchronized(lock1) {
        synchronized(lock2) {
            // ...
        }
    }
}

public void doOtherthing() {
    synchronized(lock2) {
        synchronized(lock1) {
            // ...
        }
    } 
}

now if more than one thread are trying to access these methods then there may be a deadlock because of nested synchronized blocks.

like image 21
infoj Avatar answered Sep 20 '22 08:09

infoj