今天下午学习了一下线程的死锁，写了个练习

1. public class TestDeadLock implements Runnable {
   
2.         public int flag = 1;
   
3.         static Object o1 = new Object(), o2 = new Object();
   
4.         
   
5.         public void run() {
   
6.                 System.out.println("flag: "+flag);
   
7.                 if(flag == 1) {
   
8.                         synchronized(o1) {
   
9.                                 try {
   
10.                                         Thread.sleep(500);
    
11.                                 } catch(Exception e) {
    
12.                                         e.printStackTrace();        
    
13.                                 }
    
14.                         }
    
15.                         synchronized(o2) {
    
16.                                 System.out.println("1");
    
17.                         }
    
18.                 } else {
    
19.                         synchronized(o2) {
    
20.                                 try {
    
21.                                         Thread.sleep(500);
    
22.                                 } catch(Exception e) {
    
23.                                         e.printStackTrace();        
    
24.                                 }
    
25.                         }
    
26.                         synchronized(o1) {
    
27.                                 System.out.println("2");
    
28.                         }
    
29.                 }
    
30.         }
    
31.         
    
32.         public static void main(String[] args) {
    
33.                 TestDeadLock td1 = new TestDeadLock();
    
34.                 TestDeadLock td2 = new TestDeadLock();
    
35.                 td1.flag = 1;
    
36.                 td2.flag = 0;
    
37.                 new Thread(td1).start();
    
38.                 new Thread(td2).start();
    
39.         }
    
40. }

复制代码

按道理这段代码应该出现死锁的情况，可是为什么没有出现呢

18353666072 发表于 2014-6-13 15:41
什么叫死锁：
就是A里有B，B里有A；，你中有我，我中有你，，我不让你，你不让我，，，结果就锁住了，，
...

谢谢哥们的帮助

1. 
   
2. class Test implements Runnable//实现Runnable接口
   
3. {
   
4.         private boolean flag;
   
5.         Test(boolean flag)
   
6.         {
   
7.                 this.flag=flag;
   
8.         }
   
9.         public void run()//重写run方法
   
10.         {
    
11.                 if(flag)
    
12.                 {
    
13.                         synchronized(Mylock.locka)//Mylock.locka为对象锁
    
14.                         {
    
15.                                 System.out.println("if locka");
    
16.                                 synchronized(Mylock.lockb)
    
17.                                 {
    
18.                                         System.out.println("if lockb");
    
19.                                 }
    
20.                         }
    
21.                 }
    
22.                 else
    
23.                 {
    
24.                         synchronized(Mylock.lockb)
    
25.                         {
    
26.                                 System.out.println("else lockb");
    
27.                                 synchronized(Mylock.locka)
    
28.                                 {
    
29.                                         System.out.println("else locka");
    
30.                                 }
    
31.                         }
    
32.                 }
    
33.         }
    
34. }
    
35. 
    
36. class Mylock
    
37. {
    
38.         static Object locka = new Object();
    
39.         static Object lockb = new Object();
    
40.        
    
41. 
    
42. }
    
43. class ThreadOver
    
44. {
    
45.         public static void main(String[] args)
    
46.         {
    
47.                 Thread t1= new Thread(new Test(true));
    
48.                 Thread t2= new Thread(new Test(false));
    
49.                 t1.start();
    
50.                 t2.start();
    
51.         }
    
52. }
    

复制代码

什么叫死锁：
就是A里有B，B里有A；，你中有我，我中有你，，我不让你，你不让我，，，结果就锁住了，，
告诉楼主一个学习的小技巧记住我只告诉你有一个，不要和别人说啊{:3_53:}：就是结合实际的东西把抽象的转换成自己的，看不会的，就多看几遍，以前我是囫囵吞枣，我啥也没学到，现在我改变了策略，一步一个脚印，明白一点我就前进一点，，，，这样很踏实啊有感而发，今天神经病了哈哈{:3_55:}

moon1993zs 发表于 2014-6-13 00:21
我帮你改了下程序

public class TestDeadLock implements Runnable {

看了你这个我完全懂了，谢谢啊

HF_Opticalix 发表于 2014-6-12 23:21
楼上说的很对了
1 死锁是建立在while无限循环的基础上，死锁住了才会停下
2 synchronized要嵌套 ...

非常感谢:)

alive 发表于 2014-6-12 23:07
1.while（true）  你没一直让程序运行
2. 你的同步嵌套  有问题 两个synchronized没嵌套  ...

谢谢，我知道了，主要是两个synchronized没嵌套

HF_Opticalix 发表于 2014-6-12 23:21
楼上说的很对了
1 死锁是建立在while无限循环的基础上，死锁住了才会停下
2 synchronized要嵌套 ...

我帮你改了下程序

public class TestDeadLock implements Runnable {

        public int flag = 1;

        static Object o1 = new Object(), o2 = new Object();  

        
        public void run() {

                System.out.println("flag: "+flag);
                 // while(true)  
                if(flag == 1) {

                        synchronized(o1) {

                                try {
                                        System.out.println("我是线程0---我拿到了01 锁");
                                         Thread.sleep(300);   //  这里的代码和下面的else ,sleep注释之后就难形成死锁，你可以测试下。也可是加个while(true)增加死锁
                                                                         // 形成可能性。

                                } catch(Exception e) {

                                        e.printStackTrace();        
                                }

                       

                        synchronized(o2) {// 把代码写成嵌套的形式。
                        
                           System.out.println("我是线程"+Thread.currentThread().getName()+"我到了,,,");
                              
                                
                           }
                        }

                } else {

                        synchronized(o2) {

                                try {
                                   System.out.println("我是线程1---我拿到了02 锁");
                                        Thread.sleep(300);     
                                    
                                } catch(Exception e) {

                                        e.printStackTrace();        
                                }

                                
                                synchronized(o1) {
                                 
                                 System.out.println("我是线程"+Thread.currentThread().getName()+"我到达了终点");
                                 
      
                             }
                        }

                     

                }

        }

        
        public static void main(String[] args) {

                TestDeadLock td1 = new TestDeadLock();

                TestDeadLock td2 = new TestDeadLock();

                td1.flag = 1;

                td2.flag = 0;

                new Thread(td1).start();

                new Thread(td2).start();

        }

}

//形成死锁关键是线程拿到锁。对方拿不到锁互相等待。
//希望对你有帮助。

楼上说的很对了
1 死锁是建立在while无限循环的基础上，死锁住了才会停下
2 synchronized要嵌套

1.while（true）  你没一直让程序运行
2. 你的同步嵌套  有问题 两个synchronized没嵌套

直接挂了 还说没有死锁 。。。