Re: Deadlocks

From:

Zig <none@nowhere.net>

Newsgroups:

comp.lang.java.programmer

Date:

Fri, 02 Nov 2007 15:57:45 -0400

Message-ID:

<op.t06kejko8a3zjl@mallow>

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/