1. class Ticket implements Runnable
   
2. {
   
3.         private int tick = 10000;
   
4.         Object obj = new Object();
   
5.         boolean flag = true;
   
6.         public void run()
   
7.         {
   
8.                 if(flag)//使用if else 进行转换。
   
9.                 {
   
10.                         while(true)
    
11.                         {
    
12.                                 synchronized(obj)
    
13.                                 {
    
14.                                         show();//要执行的代码
    
15.                                 }
    
16.                         }
    
17.                 }
    
18.                 else
    
19.                         while(true)
    
20.                                 show();//要执行的代码
    
21.         }
    
22.         public synchronized void show()//同步函数，用的是this锁
    
23.         {
    
24.                 synchronized(obj)
    
25.                 {
    
26.                         if(tick>0)
    
27.                         {
    
28.                                 try{Thread.sleep(10);}catch(Exception e){}
    
29.                                 System.out.println(Thread.currentThread().getName()+"........."+tick--);
    
30.                         }
    
31.                 }
    
32.         }
    
33. }
    
34. 
    
35. class  SiSuo
    
36. {
    
37.         public static void main(String[] args)
    
38.         {
    
39.                 Ticket t = new Ticket();//创建资源
    
40. 
    
41.                 Thread t1 = new Thread(t);//创建t资源的线程
    
42.                 Thread t2 = new Thread(t);
    
43.                 t1.start();//启动线程
    
44.                 try{Thread.sleep(10);}catch(Exception e){}
    
45.                 t.flag = false;
    
46.                 t2.start();
    
47.         }
    
48. }

复制代码

1. class Tick implements Runnable
   
2. {
   
3.         boolean fals;
   
4. 
   
5.         Tick(boolean fals)
   
6.         {
   
7.                 this.fals = fals;
   
8.         }
   
9.         public void run()
   
10.         {
    
11.                 if(fals)
    
12.                 {
    
13.                         while(true)
    
14.                         {
    
15.                                 synchronized(MyLock.locka)
    
16.                                 {
    
17.                                         System.out.println("if locka");
    
18.                                         synchronized(MyLock.lockb)
    
19.                                         {
    
20.                                                 System.out.println("if lockb");
    
21.                                         }
    
22.                                 }
    
23.                         }
    
24.                 }
    
25.                 else
    
26.                 {
    
27.                         synchronized(MyLock.lockb)
    
28.                         {
    
29.                                 System.out.println("else lockb");
    
30.                                 synchronized(MyLock.locka)
    
31.                                 {
    
32.                                         System.out.println("else locka");
    
33.                                 }
    
34.                         }
    
35.                 }
    
36.         }
    
37. }
    
38. class MyLock
    
39. {
    
40.         static Object locka = new Object();
    
41.         static Object lockb = new Object();
    
42. }
    
43. class SiSuo1
    
44. {
    
45.         public static void main(String[] args)
    
46.         {
    
47.                 Thread t1 = new Thread(new Tick(true));    //这里想不明白，这是不是创建了两个不同的对象?  和第一种死锁有什么不同的地方。除了锁
    
48.          Thread t2 = new Thread(new Tick(false));
    
49.                 t1.start();
    
50.                 t2.start();
    
51.         }
    
52. }

复制代码

刘胜寒 发表于 2013-4-15 10:43
第二个是创建了两个对象...
但是他们的锁是MyLock的两个成员.....
第一个代码的锁是Ticket本身的东西...

那意思是不是说，想要用两个对象实现死锁，就必须要用第三方的锁，否则就只能使用第一种方法，是这个意思吧？

第二个是创建了两个对象...
但是他们的锁是MyLock的两个成员.....
第一个代码的锁是Ticket本身的东西...
主要的区别就是
第一个只能有一个目标Runable子类实现死锁
第二个可用两个目标Runnable子类实现死锁，就是因为用的锁是第三方的东西