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