class Test implements Runnable
{
        private boolean flag;
        Object locka=new Object();
        Object lockb=new Object();
        Test(boolean flag)
        {
                this.flag=flag;
        }
        public void run()
        {
                if(flag)
                {while(true)
                        {synchronized (locka)
                                {
                                        System.out.println("if locka");
                                                synchronized (lockb)
                                                {        try
                                                        {
                                                                Thread.sleep(10);
                                                        }
                                                        catch (Exception e)
                                                        {
                                                        }
                                                        System.out.println("if lockb");
                                                }
                                }
                        }
                }
                else
                {while(true)
                        {
                                synchronized (lockb)
                                {
                                        System.out.println("else lockb");
                                                synchronized (locka)
                                                {
                                                        try
                                                        {
                                                                Thread.sleep(10);
                                                        }
                                                        catch (Exception e)
                                                        {
                                                        }
                                                        System.out.println("else locka");
                                                }
                                }
                        }
                }
        }
}
/*class MyLock
{
        static Object locka=new Object();
        static Object lockb=new Object();
}*/
class Demo2
{public static void main(String[] args)
        {
                        Thread t1=new Thread(new Test(true));
                        Thread t2=new Thread(new Test(false));
                        t1.start();
                        t2.start();
        }
}
为什么两个锁定义在本类中不出现死锁，而单独在另一个类定义的两个锁却可以出现死锁？

同样不解，期待高手回答

我知道了。
如果两个锁都是静态的，定义在本类中是可以死锁的。因为静态存在与方法区，是共享数据
如果两个锁都不是静态的， 那么每一个线程在新建对象的时候都有自己的A锁与B锁，但是这两个A和B在内存中并不是同一个锁，因此无法实现死锁

楼上正解，看了半天。。。。