1. class Ticket implements Runnable
   
2. {
   
3.         private int tic=1000;
   
4.         //重写run方法
   
5.         Object  obj = new Object();
   
6.         //定义一标记判断执行哪个线程
   
7.         boolean flag = true;
   
8.         public void run()
   
9.         {
   
10.                 if(true)
    
11.                 {
    
12.                         while(true)
    
13.                         {
    
14.                                 synchronized(obj)
    
15.                                 {
    
16.                                         synchronized(Ticket.class)
    
17.                                         {
    
18.                                                 show();
    
19.                                         }
    
20.                                 }
    
21.                         }
    
22.                 }
    
23.                         else
    
24.                                 show();
    
25.          }
    
26.                 public synchronized void show()
    
27.                 {
    
28.                         synchronized(obj)
    
29.                                 {
    
30.                                         if(tic>0)
    
31.                                         //try{Thread.sleep(10);}catch(Exception e){}
    
32.                                         System.out.println(Thread.currentThread().getName()+"---票---"+tic--);
    
33.                                 }
    
34.                 }
    
35. }
    
36.          
    
37. class Demo11
    
38. {
    
39.         public static void main(String[] args)
    
40.         {
    
41.                 Ticket tic = new Ticket();
    
42.                 Thread t1 = new Thread(tic);
    
43.                 Thread t2 = new Thread(tic);
    
44.                 t1.start();
    
45.                 tic.flag=false;
    
46.                 t2.start();
    
47.         }
    
48. }
    

复制代码

请大家看一下我这段代码，是关于多线程死锁的问题，不知道为什么没有成为死锁，还很和谐，求解!!!

亲，怎么看不到你的代码，

fenzheng 发表于 2014-5-17 11:39
亲，怎么看不到你的代码，

好了，不知道为什么刚才每传上来:lol

答案在你的第十行的代码里，if（flag）才能起作用啊，哥们要细心啊，要不然没对象。。。你懂的

同步函数的锁是this，你两个锁一个是obj 一个是Ticket.class，应该是出现第三个锁this了 才没锁上

lzhuas 发表于 2014-5-17 14:12
答案在你的第十行的代码里，if（flag）才能起作用啊，哥们要细心啊，要不然没对象。。。你懂的 ...

嗯嗯，果然是判断整错了，都给我整毛了。。。。改的自己都蒙了:lol

蒙奇.D.路飞 发表于 2014-5-17 15:15
同步函数的锁是this，你两个锁一个是obj 一个是Ticket.class，应该是出现第三个锁this了 才没锁上 ...

是if判断的问题，虽然稀里糊涂的嵌套成了有三个锁了，但是思路就没错，就是马虎了:lol

// 哥们 ，搞了2小时终于有结果了， 已经把他搞成了死锁修改了你的部分内容，你可以试试运行。

class Ticket implements Runnable
{   
           private int tick=12200;
          static  boolean flag=true;

     public void run(){
         
                    if(flag)
                      {   
                                           Ticket.flag=false;   // 把标记放到这里来
                                           synchronized(OBJ.obj1){ //锁

                                                while(true){
                                                   
                                                             try{Thread.sleep(500);}catch(Exception e){System.out.println("asdfsafsafdaasf");} // 让他冻结，t1 冻结500  
                                                                  System.out.println(Thread.currentThread().getName()+"?????"); // 测试
                                                                  System.out.println("flag...."+flag);   // 测试
                                     kk();  
                                                                 }
                                                
                                                     }
                                               
                                  }         
                    else
                          {
                                     
                                     while(true){
                                                  
                                 kk();
                                            
                                                    }
                               
                                  }

          }   

       public synchronized void kk(){  // t1 this
                  System.out.println(Thread.currentThread().getName()+"....");
                  synchronized(OBJ.obj1){

                          
                                 if(tick>0)

                                     System.out.println(Thread.currentThread().getName()+"....."+tick--);

                                       }
          
              }

}
class OBJ
{
    static Object obj1=new Object();
        static Object obj2=new Object();
}



class Thread22
{
        public static void main(String[] args)
        {            
                        Ticket ticket=new Ticket(); //创建一个对象
                        Thread t1 = new Thread(ticket);
                Thread t2 = new Thread(ticket);
                            
                t1.start();
              //ticket.flag=false;   这里代码没用，切记，，对于共享的资源要放在同步里。
                t2.start();
        }
}

格子、 发表于 2014-5-17 16:41
是if判断的问题，虽然稀里糊涂的嵌套成了有三个锁了，但是思路就没错，就是马虎了 ...

哦哦  代码就是马虎不得啊

sheng6699 发表于 2014-5-17 17:11
// 哥们 ，搞了2小时终于有结果了， 已经把他搞成了死锁修改了你的部分内容，你可以试试运行。

class Tick ...

谢谢哥们哈，问题解决了，是判断出错了，思路是对滴:lol