Re: Deadlocks
Hello,
That is a very insightfull test. However, the point of confusion I *thin=
k* =
is that the OS is free allocate processor time between threads with no =
guarantees, except that it will not allocate time to a thread currently =
=
waiting for a lock until that lock is available.
More to the point: once thread 1 releases lock ONE, the OS is free to =
transfer processor control to thread 2, which now aquires lock ONE, whic=
h =
can occur before thread 1 reaches:
System.out.println(Thread.currentThread().getName() + " GAVE UP lock on =
=
'ONE'");
Thus, a lock can only be held by one thread at a time, but they are not =
=
necessarily guaranteed to reach the println statements in the order you =
=
expect.
In your Danger.read method, you have a Thread.sleep() method between =
locks; if you make a similar sleep (or maybe Thread.yield()) in your =
Danger.write method just after you aquire lock ONE, but before the =
println, you should see the printlns occur in the expected order (99% of=
=
the time).
As an aside, I will point out that this class should not deadlock. Both =
=
threads use a consistant locking order ONE -> TWO. The danger of deadloc=
k =
really shows up when you have a locking order violation, such as when =
thread 1 uses a locking order ONE -> TWO, and thread 2 uses the locking =
=
order TWO -> ONE. Thus, there is a potential that each thread is holding=
=
the lock the other thread requires, deadlocking the two threads.
HTH,
-Zig
On Fri, 02 Nov 2007 15:23:58 -0400, <getsanjay.sharma@gmail.com> wrote:
Hello to all Java programmer out there.
I am currently reading about deadlocks and so wrote a small program
which would simulate a deadlock. But I have come across a very weird
behavior in the sense that it seems that Two threads are acquiring a
lock on an object at the same time. From what I know so far, each
object has a single lock object which a thread has to acquire to enter=
the critical section. So why the given output which seems to say that
both Thread one and Thread two have acquired a lock on the same
object?
public class DeadLockTest
{
public static void main(String[] args) throws Exception
{
Danger d = new Danger();
One one = new One(d);
one.setName("ThreadOne");
Two two = new Two(d);
two.setName("ThreadTwo");
one.start();
two.start();
}
}
class One extends Thread
{
private Danger d;
public One(Danger d)
{
this.d = d;
}
public void run()
{
while (true)
{
try
{
Thread.sleep(100);
d.write(10, 10);
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
}
class Two extends Thread
{
private Danger d;
public Two(Danger d)
{
this.d = d;
}
public void run()
{
while (true)
{
try
{
Thread.sleep(100);
d.read();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
}
class Danger
{
static class Resource
{
int value;
Resource(int value)
{
this.value = value;
}
int getValue()
{
return (value);
}
}
private Resource one = new Resource(10);
private Resource two = new Resource(20);
public void read() throws Exception
{
synchronized (one)
{
System.out.println(Thread.currentThread().getName() + "
ACQUIRED lock on 'ONE'");
Thread.sleep(400);
synchronized (two)
{
System.out.println(Thread.currentThread().getName() +
" acquired lock on 'TWO'");
System.out.println(Thread.currentThread().getName()
+ " : The value is " + (one.getValue() +
two.getValue()));
}
System.out.println(Thread.currentThread().getName() + "
GAVE UP lock on 'TWO'");
}
System.out.println(Thread.currentThread().getName() + " GAVE
UP lock on 'ONE'");
}
public void write(int a, int b)
{
synchronized (one)
{
System.out.println(Thread.currentThread().getName() + "
ACQUIRED lock on 'ONE'");
synchronized (two)
{
System.out.println(Thread.currentThread().getName() +
" ACQUIRED lock on 'TWO'");
one.value = (one.value + a) % Integer.MAX_VALUE;
two.value = (two.value + a) % Integer.MAX_VALUE;
System.out.println(Thread.currentThread().getName()
+ " : Setting values " + one.value + " and " +=
two.value);
}
System.out.println(Thread.currentThread().getName() + "
GAVE UP lock on 'TWO'");
}
System.out.println(Thread.currentThread().getName() + " GAVE
UP lock on 'ONE'");
}
}
/*
OUTPUT ->
[..]
ThreadOne ACQUIRED lock on 'ONE'
ThreadOne ACQUIRED lock on 'TWO'
ThreadOne : Setting values 20 and 30
ThreadOne GAVE UP lock on 'TWO'
ThreadOne GAVE UP lock on 'ONE'
ThreadTwo ACQUIRED lock on 'ONE'
ThreadTwo acquired lock on 'TWO'
ThreadTwo : The value is 50
ThreadTwo GAVE UP lock on 'TWO'
ThreadOne ACQUIRED lock on 'ONE'
ThreadOne ACQUIRED lock on 'TWO'
ThreadOne : Setting values 30 and 40
ThreadOne GAVE UP lock on 'TWO'
ThreadOne GAVE UP lock on 'ONE'
ThreadTwo GAVE UP lock on 'ONE'
[..]
*/
Links / Explanations / Comments / Suggestions would be really
appreciated.
Thanks and regards,
STS
-- =
Using Opera's revolutionary e-mail client: http://www.opera.com/mail/