aspose file tools*
The moose likes Java in General and the fly likes Deadlock scenario Big Moose Saloon
  Search | Java FAQ | Recent Topics | Flagged Topics | Hot Topics | Zero Replies
Register / Login
JavaRanch » Java Forums » Java » Java in General
Bookmark "Deadlock scenario" Watch "Deadlock scenario" New topic
Author

Deadlock scenario

john sal
Ranch Hand

Joined: Jul 30, 2010
Posts: 93
Following is a dead lock scenario



if the methods are called in the following way then it may result in deadlock situation.

Thread 1: parent.addChild(child); //locks parent
--> child.setParentOnly(parent);

Thread 2: child.setParent(parent); //locks child
--> parent.addChildOnly()

Now my question is what changes can be made in the code so that we can perform the above two operations without causing deadlock.
Rob Spoor
Sheriff

Joined: Oct 27, 2005
Posts: 19697
    
  20

Don't make the methods synchronized but use synchronized blocks inside the method. This gives you a finer grained control over when locks are acquired. In this case you have two options:
- always get the parent lock first, then the child lock
- always get the child lock first, then the parent lock

It doesn't really matter which one you choose. The import thing is that the order is always the same, no matter which two objects are called.
In the following code I chose the second option:
Note that two methods are still fully synchronized. That's because there is only one lock acquired when those methods are called, so they introduce no extra risk of deadlock.

There is still a potential for deadlock, if you are treating two TreeNodes as both parent and child, e.g. by adding them to each other.


SCJP 1.4 - SCJP 6 - SCWCD 5 - OCEEJBD 6
How To Ask Questions How To Answer Questions
Mike Simmons
Ranch Hand

Joined: Mar 05, 2008
Posts: 3014
    
  10
Before considering how to also handle the last case Rob mentioned (if you choose to do so), I think it may be helpful to simplify the code a bit. Consider:

Should setChildOnly() and setParentOnly() be public at all? It seems to me that the public API should only be methods which will leave the two objects in a consistent state, ensuring bidirectional links. What reason does anyone outside this class have for calling setChildOnly() or setParentOnly()? For that matter, I'm not sure if anyone inside this class really needs both of these methods. That can be decided later.

Do we need complex synchronization code inside both setChild() and setParent()? Or can we just call one method from the other?

In fact I'm not sure both these methods need to be part of the public API, as it's easy for someone to mistakenly think they need to call both of them - they don't. And anyone who wants to call a.setParent(b) can easily call b.addChild(a) instead, and be done.

Now, "complex stuff" could be exactly what Rob wrote for addChild() - it works well for everything except the case he noted, two nodes (accidentally?) made children of each other. If you want to also handle that case, I think it's probably easiest to avoid using synchronization entirely, and instead use either (a) methods from java.util.locks.Lock, or (b) optimistic locking techniques using AtomicInteger or AtomicLong. I recommend Java Concurrency in Practice if you want to learn about these techniques in detail.
 
I agree. Here's the link: http://aspose.com/file-tools
 
subject: Deadlock scenario