Deadlocks

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 'TWO'
ThreadTwo : The value is 50
ThreadTwo GAVE UP lock on 'TWO'


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