黑马程序员技术交流社区

标题: 下列代码无法实现死锁，我的程序运行还是会正确执行完。 [打印本页]
作者: 张 涛    时间: 2012-9-6 17:34
标题: 下列代码无法实现死锁，我的程序运行还是会正确执行完。
本帖最后由 张 涛 于 2012-9-12 09:47 编辑
  1. public class TestDeadLock implements Runnable{
  2.     public int flag = 2;
  3.     static Object o1 = new Object();
  4.     static Object o2 = new Object();
  5.    
  6.     public void run(){
  7.         if(flag == 1){
  8.             synchronized(o1){
  9.                 System.out.println("锁住o1");   
  10.                 try {
  11.                     Thread.sleep(5000);
  12.                 }catch(Exception e){}
  13.             }
  14.             
  15.             synchronized(o2){
  16.                 System.out.println("1");
  17.             }
  18.         }
  19.         //疑问：无法死锁
  20.         if(flag == 0){
  21.             synchronized(o2){
  22.                 System.out.println("锁住o2");
  23.                 try {
  24.                     Thread.sleep(5000);
  25.                 }catch(Exception e){}
  26.             }
  27.             
  28.             synchronized(o1){
  29.                 System.out.println("2");
  30.             }
  31.         }
  32.     }
  33.    
  34.     public static void main(String[] args){
  35.         TestDeadLock td1 = new TestDeadLock();
  36.         TestDeadLock td2 = new TestDeadLock();
  37.         td1.flag = 1;
  38.         td2.flag = 0;
  39.         Thread t1 = new Thread(td1);
  40.         Thread t2 = new Thread(td2);
  41.         t1.start();
  42.         t2.start();
  43.     }
  44. }
复制代码
我的理解是，两个线程分别锁住两个对象，再等待获取另一个对象的线程锁，那么此时会形成死锁，但是实际是没有死锁，还能正确运行到结束。
作者: 武庆东    时间: 2012-9-6 17:41
本帖最后由 武庆东 于 2012-9-6 17:55 编辑

public class TestDeadLock implements Runnable{
    public String name;
    static Object os = new Object();
    public TestDeadLock(String name){
        this.name=name;
    }
   
   
    public void run(){
         synchronized(os){
                System.out.println("锁住线程"+name);   
                try {
                    Thread.sleep(5000);
                }catch(Exception e){}
            
            
         
        }
      
    }
   
    public static void main(String[] args){
        TestDeadLock td1 = new TestDeadLock("A");
        TestDeadLock td2 = new TestDeadLock("B");
     
        Thread t1 = new Thread(td1);
        Thread t2 = new Thread(td2);
        t1.start();
        t2.start();
    }
}
注意：使用同步代码块格式
synchronized(同步对象){
  需要同步的代码块
}

作者: 全海波    时间: 2012-9-6 17:47
本帖最后由 全海波 于 2012-9-6 17:48 编辑


  2. <BLOCKQUOTE>
  3. <P> </P>
  4. <P>你拿的根本就不是同一锁，当然不会出现死锁，对你的代码修改如下：</P>
复制代码
  1. 01.public class TestDeadLock implements Runnable{

  3. 02. public int flag = 2;

  5. 03. static Object o1 = new Object();

  7. 04. static Object o2 = new Object();

  9. 05.

  11. 06. public void run(){

  13. 07. if(flag == 1){

  15. 08. synchronized(o1){

  17. 09. System.out.println("锁住o1");

  19. 10. try {

  21. 11. Thread.sleep(5000);

  23. 12. }catch(Exception e){}

  25. 13. }

  27. 14.

  29. 15. synchronized(o2){

  31. 16. System.out.println("1");

  33. 17. }

  35. 18. }

  37. 19. //疑问：无法死锁

  39. 20.
  40. public synchronized void run2()
  41. {
  42. if(flag == 0){

  44. 21. synchronized(o1){

  46. 22. System.out.println("锁住o2");

  48. 23. try {

  50. 24. Thread.sleep(5000);

  52. 25. }catch(Exception e){}

  54. 26. }

  56. 27.

  58. 28. synchronized(o1){

  60. 29. System.out.println("2");

  62. 30. }

  64. 31. }

  66. 32. }
  67. }

  69. 34. public static void main(String[] args){

  71. 35. TestDeadLock td1 = new TestDeadLock();

  73. 36. TestDeadLock td2 = new TestDeadLock();

  75. 37. td1.flag = 1;

  77. 38. td2.flag = 0;

  79. 39. Thread t1 = new Thread(td1);

  81. 40. Thread t2 = new Thread(td2);

  83. 41. t1.start();

  85. 42. t2.start();

  87. 43. }

  89. 44.}
复制代码
作者: 佟亚鹏    时间: 2012-9-6 18:38
楼主你的代码是这样走的，flat == 1中的代码，锁住o1时，继续往下执行去尝试锁住o2，这个时候flat == 0中的代码，锁o2的代码可能已经执行完了，所以flat == 1中可以顺利的锁住o2，flat == 0中也是一样，当它去锁o1时锁也应经放开了，
你这个代码修改一点点就行了，思路是让flat == 1中锁住o1等待锁住o2，flat == 0中锁住o2等待锁住o1，让他们俩一门报一个锁并等待另外一个锁，他俩都不放开，所以死锁了
具体代码：
  1. public class TestDeadLock implements Runnable{
  2.     public int flag = 2;
  3.     static Object o1 = new Object();
  4.     static Object o2 = new Object();
  5.    
  6.     public void run(){
  7.         if(flag == 1){
  8.             synchronized(o1){
  9.                 System.out.println("锁住o1");                  
  10.                 try {
  11.                     Thread.sleep(5000);
  12. //锁o2的代码放在已经锁住o1的里面
  13. //睡眠5秒确保另外一个线程已经锁住了o2
  14.                     synchronized(o2){
  15.                         System.out.println("1");
  16.                     }
  17.                 }catch(Exception e){}
  18.             }
  19.             
  20.            
  21.         }
  22.         //疑问：无法死锁
  23.         if(flag == 0){
  24.             synchronized(o2){
  25.                 System.out.println("锁住o2");               
  26.                 try {
  27. //锁o1的代码放在已经锁住o2的里面
  28. //睡眠5秒确保另外一个线程已经锁住了o1
  29.                     Thread.sleep(5000);
  30.                         synchronized(o1){
  31.                     System.out.println("2");
  32.                 }
  33.                 }catch(Exception e){}
  34.             }         
  35.         }
  36.     }
  37.    
  38.     public static void main(String[] args){
  39.         TestDeadLock td1 = new TestDeadLock();
  40.         TestDeadLock td2 = new TestDeadLock();
  41.         td1.flag = 1;
  42.         td2.flag = 0;
  43.         Thread t1 = new Thread(td1);
  44.         Thread t2 = new Thread(td2);
  45.         t1.start();
  46.         t2.start();
  47.     }
  48. }
复制代码
锁住o1
锁住o2

他们俩都抱住一个锁，等待另外一个锁，程序停住了。。。。。ok,楼主复制回去看看，只是把锁资源的代码改改位置就可以了
作者: 袁艳超    时间: 2012-9-6 18:41
一个拿到o1对象准备去拿o2，另一个拿到o2对象准备去拿o1;
你写的代码意思是:
第一个拿到o1后,锁住o1,sleep 5秒,释放o1,去取o2
第二个拿到o2后,锁住o2,sleep 5秒,释放o2,去取o1;
那么,不管是谁睡5秒后,都会释放掉自己手里的锁的,
改成如下代码:
public class TestDeadLock implements Runnable {
        public int flag = 2;
        static Object o1 = new Object();
        static Object o2 = new Object();

        public void run() {
                if (flag == 1) {
                        synchronized (o1) {
                                System.out.println("锁住o1");
                                // Thread.currentThread().interrupt();         //如果任意一个线程打断的话,就会运行到结束
                                synchronized (o2) {                                //不用加sleep(5000)
                                        System.out.println("1");   //这样的代码才是锁住o1,想要获得o2
                                }                        }

                }
                // 疑问：无法死锁
                if (flag == 0) {
                        synchronized (o2) {
                                System.out.println("锁住o2");
                                synchronized (o1) {                  //这样的代码才是锁住o2,想要获得o1
                                        System.out.println("2");
                                }                        }

                }
        }

        public static void main(String[] args) {
                TestDeadLock td1 = new TestDeadLock();
                TestDeadLock td2 = new TestDeadLock();
                td1.flag = 1;
                td2.flag = 0;
                Thread t1 = new Thread(td1);
                Thread t2 = new Thread(td2);
                t1.start();
                t2.start();
        }
}
作者: 张 涛    时间: 2012-9-12 09:46
搞定，结贴，谢谢。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2