/*
本例是day11天最后一个视频中关于死锁的例子，
当时毕老师用MyLock类的2个静态对象实现锁，我之后试了下非静态的锁对象，发现锁不住了。
代码如下所示，除了注释之处，其他地方未曾改动。
不知道哪里出了问题，求助大家。
希望大家能用截图证明自己的程序，谢谢。
*/
class Test implements Runnable
{
        private boolean flag;
        Test(boolean flag)
        {
                this.flag = flag;
        }

        public void run()
        {
                MyLock lock = new MyLock();     //为了使用非静态锁对象而新建的MyLock类的lock对象
               
                if(flag)
                {
                        while(true)
                        {
                                synchronized(lock.locka)  //非静态lock.locka锁对象
                                {
                                        System.out.println(Thread.currentThread().getName()+"...if locka ");

                                        synchronized(lock.lockb) //非静态lock.lockb锁对象
                                        {
                                                System.out.println(Thread.currentThread().getName()+"..if lockb");                                       
                                        }
                                }
                        }
                }
                else
                {
                        while(true)
                        {
                                synchronized(lock.lockb) //非静态lock.lockb锁对象
                                {
                                        System.out.println(Thread.currentThread().getName()+"..else lockb");

                                        synchronized(lock.locka) //非静态lock.locka锁对象
                                        {
                                                System.out.println(Thread.currentThread().getName()+".....else locka");
                                        }
                                }
                        }
                }
        }
}

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

class  DeadLockTest
{
        public static void main(String[] args)
        {
                Thread t1 = new Thread(new Test(true));
                Thread t2 = new Thread(new Test(false));
                t1.start();
                t2.start();
        }
}

1. class Test implements Runnable
   
2. 
   
3. {   
   
4.         private boolean flag;
   
5.         MyLock lock ;           
   
6.         Test(boolean flag,MyLock lock)  //讲 lock 作为参数 由构造器传入  这样就可以保证使用同一个 lock lock 下的对象也是相同的
   
7.         {
   
8.                 this.flag = flag;
   
9.                 this.lock =lock;
   
10.         }
    
11. 
    
12.         public void run()
    
13.         {
    
14.                
    
15.                 if(flag)
    
16.                 {
    
17.                         while(true)
    
18.                         {
    
19.                                 synchronized(lock.locka)  //非静态lock.locka锁对象
    
20.                                 {
    
21.                                         System.out.println(Thread.currentThread().getName()+"...if locka ");
    
22. 
    
23.                                         synchronized(lock.lockb) //非静态lock.lockb锁对象
    
24.                                         {
    
25.                                                 System.out.println(Thread.currentThread().getName()+"..if lockb");                                       
    
26.                                         }
    
27.                                 }
    
28.                         }
    
29.                 }
    
30.                 else
    
31.                 {
    
32.                         while(true)
    
33.                         {
    
34.                                 synchronized(lock.lockb) //非静态lock.lockb锁对象
    
35.                                 {
    
36.                                         System.out.println(Thread.currentThread().getName()+"..else lockb");
    
37. 
    
38.                                         synchronized(lock.locka) //非静态lock.locka锁对象
    
39.                                         {
    
40.                                                 System.out.println(Thread.currentThread().getName()+".....else locka");
    
41.                                         }
    
42.                                 }
    
43.                         }
    
44.                 }
    
45.         }
    
46. }
    
47. 
    
48. class MyLock
    
49. {
    
50.         Object locka = new Object();
    
51.         Object lockb = new Object();
    
52. }
    
53. 
    
54. public class  DeadLockTest
    
55. {
    
56.         public static void main(String[] args)
    
57.         {
    
58.                 MyLock lock = new MyLock();
    
59.                        
    
60.                                
    
61.                 Thread t1 = new Thread(new Test(true,lock));
    
62.                 Thread t2 = new Thread(new Test(false,lock));
    
63.                 t1.start();
    
64.                 t2.start();
    
65.         }
    
66. }
    

复制代码

仔细看这里：Thread t1 = new Thread(new Test(true));
                Thread t2 = new Thread(new Test(false));
你在创建线程时  新建了 两个 Test 对象，这两个对象里 创建的 Mylock 对象是不同的 ，当然无法锁住对方了。
要保证同步代码使用的是同一把锁

丁二跃 发表于 2012-7-14 10:25
仔细看这里：Thread t1 = new Thread(new Test(true));
                Thread t2 = new Thread(new Test( ...

非常清晰，谢谢这位兄弟的指点~~

看看。。。