class Demo
{
        public static void main(String[] args)
        {
                TicketWindow tw=new TicketWindow();

                Thread th1=new Thread(tw);

                Thread th2=new Thread(tw);
               
                th1.setName("tom");
                th2.setName("james");

                th1.start();

                try{Thread.sleep(1);}catch(Exception e){}

                th2.start();
        }
}
class TicketWindow implements Runnable
{
        private int ticketNum=100;
        private boolean flag=true;

        Object obj=new Object();
        public synchronized void sellTicket1(){
                flag=false;
                try{Thread.sleep(10);}catch(Exception e){}
                if(ticketNum>0){
                        System.out.println(Thread.currentThread().getName()+" 买到了第"+ticketNum+"张票");
                        ticketNum--;
                       
                }
        }
        public void sellTicket2(){
                flag=true;
                synchronized(this){
                        try{Thread.sleep(10);}catch(Exception e){}
                        synchronized(obj){
                                if(ticketNum>0){                                               
                                        System.out.println(Thread.currentThread().getName()+" 买到了第"+ticketNum+"张票");

                                        ticketNum--;
                                }
                        }
                }
        }

        public void run(){
                while(true){
                        if(flag){
                                synchronized(obj){

                                        sellTicket1();
                                }

                        }else{
                                        sellTicket2();
                               
                        }
                }
        }
}
怎样出现的死锁

        第一线程在执行时，首先得到了obj这把锁，然后，得到了this这把锁.

        当里层执行完成后，会this锁释放掉，

        它想要继续执行，就要得到obj这把锁，但是第一个线程拥有这把锁，

   
        如果这时第二个线程执行时，它首先获得了this这把锁，

        第二个线程要等待第一个线程将obj锁释放。

        第一个线程继续执行，它要想执行，还要得到this这把锁，
        this这把锁在第二个线程上，这时就出现了死锁的问题

        第一个线程拥有obj这把锁,要得到this这把锁才运行，
        第二个线程拥有this这把锁，要得到obj这把锁才运行.

  说的好，相当之明白