class Test implements Runnable
{
        private boolean flag ;
        Test(boolean flag)
        {
                this.flag = flag;
        }

        public void run()
        {
                if(flag)
                {
                        while(true)
                        {
                                synchronized(MyLock.locka)
                                {
                                        System.out.println("if.....locka");
                                        synchronized(MyLock.lockb)
                                        {
                                                System.out.println("if.....lockb");
                                               
                                        }
                                }
                        }
                }
                else
                {
                        while(true)
                        {
                                synchronized(MyLock.lockb)
                                {
                                        System.out.println("else.....lockb");
                                        synchronized(MyLock.locka)
                                        {
                                                System.out.println("else.....locka");
                                               
                                        }
                                }
                        }
                }
        }

}


class MyLock
{
        public static Object locka = new Object();
        public static Object lockb = new Object();
}


class DeadLockTest
{
        public static void main(String[] args)
        {
                Test a = new Test(true);
                Test b = new Test(false);

                Thread t1 = new Thread(a);
                Thread t2 = new Thread(b);

                t1.start();
                t2.start();
               
        }
}

你想知道什么？

最常见的死锁情况：同步嵌套。
同步中还有同步，两个同步用的不是一个锁。
记住尽量避免同步嵌套的情况。

代码实现;
class Ticket implements Runnable
{
        private int num = 200;
        private Object obj = new Object();
        private boolean flag = true;
        public  void run()
        {
//                System.out.println("run :"+this);
                if(flag)//为true就执行同步代码块。
                        while(true)
                        {
                                synchronized(obj)
                                {
                                        show();
                                }
                        }
                else//为false就执行同步函数。
                        while(true)
                        {
                                show();
                        }
        }
        /*
        将标记改为false。
        */
        public void setFlag()
        {
                flag = false;
        }

        public synchronized void show()//this
        {
                synchronized(obj)
                {
                        if(num>0)
                        {
                                try{Thread.sleep(10);}catch(InterruptedException e){}
                                System.out.println(Thread.currentThread().getName()+"............sale....."+num--);
                        }
                }
        }
}

class DeadLockDemo
{
        public static void main(String[] args)
        {
                Ticket t = new Ticket();
//                System.out.println("t:"+t);
               
                //创建线程对象。
               
                Thread t1 = new Thread(t);
                Thread t2 = new Thread(t);

                t1.start();
                try{Thread.sleep(10);}catch(InterruptedException e){}
                //在开启了t1后，将标记置为false。
                t.setFlag();

                t2.start();
        }
}
希望对楼主有帮助。
我们才学过的。

死锁就是多个线程公用相同的锁，将一个锁套在另一个锁里面。线程彼此需要对方的锁才能进行程序。   你主方法中创建了2个线程，启动后都会去执行程序class MyLock
{
        public static Object locka = new Object();
        public static Object lockb = new Object();
}
你创建了2个静态的锁。可以被所有对象使用。所以两个线程中的锁是相同的。线程启动后都抢占执行权。当一个线程（假如t1）走到  
if(flag)
                {
while(true)
                        {
                                synchronized(MyLock.locka)
                                {
                                        System.out.println("if.....locka");
                                        synchronized(MyLock.lockb)
                                        {
                                                System.out.println("if.....lockb");

中的第一个锁内时即  synchronized(MyLock.locka)
                                {
                                        System.out.println("if.....locka");
，另一个线程（假如t2）走到
else
                {
                        while(true)
                        {
                                synchronized(MyLock.lockb)
                                {
                                        System.out.println("else.....lockb");
                                        synchronized(MyLock.locka)
                                        {
                                                System.out.println("else.....locka");
                                                
它中的第一个锁时即 synchronized(MyLock.lockb)
                                {
                                        System.out.println("else.....lockb");
，t1需要lockb才能继续走下去，t2需要locka猜能走下去，但是彼此又都占用这双方需要的锁。都不能得到。所以就死锁了。

简单说就是线程A想访问线程B占用的b资源,而同时,B想访问A占有的a资源,A和B都无法释放,访问想访问的资源,就造成了死锁.解决死锁可以用同步

个人认为如果想解决死锁的问题，是需要好好的去看一下操作系统关于这方面的讲解的。关键其实就是P和V操作要理解，然后去看一下例如经典的消费者生产者模型和哲学家进餐模型，然后再遇到可能会出现死锁的状况时，思路会很清晰