Deadlock:
A special category of error which you required to permit which associate specifically to multitasking is deadlock that occurs when two threads have a circular dependency on a pair of synchronized objects. For instance, assume one thread enters the monitor on object X and another thread enters the monitor on object as T. It will block as expected if the thread in tries to call any synchronized methods on Y. Therefore, if the thread in Y in turn tries to call any synchronized method on X, the thread waits forever, because to access X. it would have to release its own lock on Y so which the first thread could finished. A Deadlock is a difficult error to debug by two reasons:
- In common, it occurs only rarely whenever the two threads time-slice in only the right way.
- It might include more than two threads and synchronized objects. (That is, deadlock could occur by a more convoluted sequence of events than just described.)
For understand deadlock fully, it is useful to see it in action. The further example creates two classes, A and B, along methods foo( ) and bar ( ) correspondingly, that pause briefly before trying to call a method in the other class. The main class which named Deadlock, creates an A and a B example, and then begins a second thread to set up the deadlock condition. A foo( ) and bar ( ) methods use sleep ( ) as a way to force the deadlock condition to occur.
/ / An example of deadlock.
class A {
synchronized void foo (B b) {
String name = Thread.currenThread ( ).getName( );
system.out.prinln (name + "entered A.foo");
try {
Thrad.sleep (1000);
}catch (Exception e) {
System.out.println ("A Interupted");
}
System.out.println(name + "trying to call B last ( )" );
b.last ( );
}
synchronized void last ( ) {
system.out.println("Inside A. last");
}
}
class B {
synchronized void bar (A a) {
String name = Thread.currentThread ( ). getName( );
System.out.println (name + "entered B.bar");
try { Thread.sleep(1000);
} catch (Exception e) {
System.out.println ("B interrupted");
}
system.out.println (name + "trying to call A.last ( )" );
a.last ( );
}
synchronized void last ( ) {
System.out.println("Inside A.last");
}
}
class Deadlock implements Runnable {
A a = new A ( ) ;
B b = new B ( );
Deadlock ( ) {
Thread.currentThread ( ).setName ("MainThread");
Thread t = new Thread (this, "RachingThread") ;
t.start ( );
a.foo (b); / / get lock on a in this thread.
system.out.println ("Back in main thread");
}
public void run( ) {
b.bar(a); / / get lock on b in other thread.
System.out.println ("Back in other thread");
}
public static void main(String args [ ] ) {
new Deadlock ( );
}
}
whenever you execute this program you will see the output display here:
MainThread entered A.foo
RachinThread entered B.bar
MainThread trying to call B. last ( )
RacingThread trying to call A. last ( )
Since the program has deadlocked, you required to press CTRL-C to end the program. You could see a full thread and monitor cache dump through pressing CTRL-BREAK on a PC (or CTRL-\on Solaris).You will see in which Racing Thread owns the monitor on b, although it is waiting for the monitor on a. At the similar time, Main Thread own a and is waiting to get b. This program will never finish. As this instance description, if your multithreaded program locks up occasionally, deadlock is one of the first conditions that you should check for.