A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

本帖最后由 黄奕豪 于 2012-5-19 16:02 编辑

郁闷了,我都把代码改成这样了,还是出现不了死锁,怎么运行都不行,是代码有问题?还是难道我的电脑是神器?还是Win7有自动避免死锁的功能?
答案正如下面2楼的兄台所说,新建的每个线程都拥有了两个锁,罪过罪过,代码不改过来了!!大家好好琢磨琢磨~~~谢谢回帖的兄弟们!!!
  1. /*
  2.         死锁程序,两个执行线程各持一个锁,然后想用对方方法的锁,相持不下,死锁
  3. */

  4. class DeadLock implements Runnable
  5. {
  6.         int i = 0;
  7.         private boolean flag;
  8.         public DeadLock(boolean m){flag=m;}
  9.         //新建两个锁
  10.         Object suo1=new Object();
  11.         Object suo2=new Object();
  12.         public void run()
  13.         {               
  14.                 if(flag)
  15.                 {
  16.                         //无限循环,让锁1里面有锁2
  17.                         while(true)//第一次不行后添加无限循环
  18.                         {
  19.                                 synchronized(suo1)
  20.                                 {
  21.                                         System.out.println("if Locka"+i);//打印添加了个序号i,用以区别两次不同的打印!!
  22.                                         i++;
  23.                                         try{Thread.sleep(100);}catch(Exception e){}//第二次不行后添加睡眠时间。一个睡100ms,一个睡10ms
  24.                                         synchronized(suo2)
  25.                                         {
  26.                                                 System.out.println("if Lockb"+i);
  27.                                                 i++;
  28.                                         }
  29.                                 }
  30.                         }
  31.                 }               
  32.                 else
  33.                 {
  34.                         //无限循环,让锁21里面有锁1
  35.                         while(true)
  36.                         {
  37.                                 synchronized(suo2)
  38.                                 {
  39.                                         System.out.println("else Lockb"+i);
  40.                                         i++;
  41.                                         try{Thread.sleep(10);}catch(Exception e){}
  42.                                         synchronized(suo1)
  43.                                         {
  44.                                                 System.out.println("else Locka"+i);
  45.                                                 i++;
  46.                                         }
  47.                                 }
  48.                         }
  49.                 }
  50.         }
  51. }

  52. class  DeadLockDemo
  53. {
  54.         public static void main(String[] args)
  55.         {
  56.                 DeadLock d1=new DeadLock(true);
  57.                 DeadLock d2=new DeadLock(false);
  58.                 Thread t1=new Thread(d1);
  59.                 Thread t2=new Thread(d2);
  60.                 t1.start();
  61.                 t2.start();
  62.         }
  63. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
贠(yun)靖 + 1 你这有4个锁 而不是两个锁 d1对象两个 d2对.

查看全部评分

6 个回复

倒序浏览
public class DeadLock {

        public static void main(String[] args) {
                final Object lock1 = new Object();
                final Object lock2 = new Object();

                new Thread() {
                        public void run() {
                                synchronized (lock1) {
                                        System.out.println(getName() + " lock1已锁定");
                                       
                                        synchronized (lock2) {                        // 有可能下面的线程已经将lock2作为锁对象进行同步, 当前线程等待
                                                System.out.println(getName() + " lock2已锁定");
                                        }
                                        System.out.println(getName() + " lock2已释放");
                                }
                                System.out.println(getName() + " lock1已释放");

                        }
                }.start();

                new Thread() {
                        public void run() {
                                synchronized (lock2) {
                                        System.out.println(getName() + " lock2已锁定");
                                       
                                        synchronized (lock1) {                        // 有可能上面的线程已经将lock1作为锁对象进行同步, 当前线程等待
                                                System.out.println(getName() + " lock1已锁定");
                                        }
                                        System.out.println(getName() + " lock1已释放");
                                }
                                System.out.println(getName() + " lock2已释放");
                        }
                }.start();
        }

}

你的代码有点乱  这代码就是专说死锁的
不过死锁也是有几率
上面这代码 如果打印
Thread-0 lock1已锁定
Thread-0 lock2已锁定
Thread-0 lock2已释放
Thread-0 lock1已释放
Thread-1 lock2已锁定
Thread-1 lock1已锁定
Thread-1 lock1已释放
Thread-1 lock2已释放

那就是没死锁
如果是
Thread-0 lock1已锁定
Thread-1 lock2已锁定

那就是死锁了   

看着可以好好想下  

评分

参与人数 1技术分 +1 收起 理由
贠(yun)靖 + 1 这个死锁程序不错 简单明了

查看全部评分

回复 使用道具 举报

  1. public class Text1 {

  2. }
  3. /*
  4. 死锁程序,两个执行线程各持一个锁,然后想用对方方法的锁,相持不下,死锁
  5. */

  6. class DeadLock implements Runnable
  7. {
  8. int i = 0;
  9. private boolean flag;
  10. public DeadLock(boolean m){flag=m;}
  11. //新建两个锁
  12. static Object suo1=new Object();
  13. static Object suo2=new Object();
  14. public void run()
  15. {               
  16.         if(flag)
  17.         {
  18.                 //无限循环,让锁1里面有锁2
  19.                 while(true)//第一次不行后添加无限循环
  20.                 {
  21.                         synchronized(suo1)
  22.                         {
  23.                                 System.out.println("if Locka"+i);//打印添加了个序号i,用以区别两次不同的打印!!
  24.                                 i++;
  25.                                 try{Thread.sleep(100);}catch(Exception e){}//第二次不行后添加睡眠时间。一个睡100ms,一个睡10ms
  26.                                 synchronized(suo2)
  27.                                 {
  28.                                         System.out.println("if Lockb"+i);
  29.                                         i++;
  30.                                 }
  31.                         }
  32.                 }
  33.         }               
  34.         else
  35.         {
  36.                 //无限循环,让锁21里面有锁1
  37.                 while(true)
  38.                 {
  39.                         synchronized(suo2)
  40.                         {
  41.                                 System.out.println("else Lockb"+i);
  42.                                 i++;
  43.                                 try{Thread.sleep(10);}catch(Exception e){}
  44.                                 synchronized(suo1)
  45.                                 {
  46.                                         System.out.println("else Locka"+i);
  47.                                         i++;
  48.                                 }
  49.                         }
  50.                 }
  51.         }
  52. }
  53. }

  54. class  DeadLockDemo
  55. {
  56. public static void main(String[] args)
  57. {
  58.         DeadLock d1=new DeadLock(true);
  59.         DeadLock d2=new DeadLock(false);
  60.         Thread t1=new Thread(d1);
  61.         Thread t2=new Thread(d2);
  62.         t1.start();
  63.         t2.start();
  64. }
  65. }
复制代码
你的锁根本无效你创了2个DeadLock 对象 在创建2个线程把对象分别放进2个线程  等于你创建2个DeadLock 线程对象  而你的DeadLock 类中创建了2把锁  又没有拿静态修饰它所有每个对象都有2把锁 你这代码就有4把锁 对象和对象指向的锁没有关联你怎么锁的主 你可以传锁进去也可以把锁让静态修饰问题就解决了

评分

参与人数 1技术分 +1 收起 理由
贠(yun)靖 + 1 赞一个!

查看全部评分

回复 使用道具 举报
楼主和我有着同样的困惑啊,楼上的说法不是很理解,这个锁是Static的呀 为啥还是出现不了死锁现象呢?
回复 使用道具 举报
你也可以只创建一个线程实例  丢进2个线程对象中  这样头前的变量不需要加静态修饰
但是这样就赵成了flag=ture不能执行 还是不会死锁
所有你要提供一个修改flag 的方法 让线程1启动之后  主线程sleep  让cpu运行线程1 线程的同步快里sleep切换到主线程 在把flag设置为true  线程2启动

  1. public class Text1 {

  2. }
  3. /*
  4. 死锁程序,两个执行线程各持一个锁,然后想用对方方法的锁,相持不下,死锁
  5. */

  6. class DeadLock implements Runnable
  7. {
  8. int i = 0;
  9. private boolean flag;
  10. public DeadLock(boolean m){flag=m;}
  11. //新建两个锁
  12. Object suo1=new Object();
  13. Object suo2=new Object();
  14. public void setFlag(boolean flag){
  15.         this.flag=flag;
  16. }
  17. public DeadLock(Object lock1,Object lock2){
  18.         suo1=lock1;
  19.         suo2=lock2;
  20. }
  21. public void run()
  22. {               
  23.         if(flag)
  24.         {
  25.                 //无限循环,让锁1里面有锁2
  26.                 while(true)//第一次不行后添加无限循环
  27.                 {
  28.                         synchronized(suo1)
  29.                         {
  30.                                 System.out.println("if Locka"+i);//打印添加了个序号i,用以区别两次不同的打印!!
  31.                                 i++;
  32.                                 try{Thread.sleep(100);}catch(Exception e){}//第二次不行后添加睡眠时间。一个睡100ms,一个睡10ms
  33.                                 synchronized(suo2)
  34.                                 {
  35.                                         System.out.println("if Lockb"+i);
  36.                                         i++;
  37.                                 }
  38.                         }
  39.                 }
  40.         }               
  41.         else
  42.         {
  43.                 //无限循环,让锁21里面有锁1
  44.                 while(true)
  45.                 {
  46.                         synchronized(suo2)
  47.                         {
  48.                                 System.out.println("else Lockb"+i);
  49.                                 i++;
  50.                                 try{Thread.sleep(10);}catch(Exception e){}
  51.                                 synchronized(suo1)
  52.                                 {
  53.                                         System.out.println("else Locka"+i);
  54.                                         i++;
  55.                                 }
  56.                         }
  57.                 }
  58.         }
  59. }
  60. }

  61. class  DeadLockDemo
  62. {
  63. //public static void main(String[] args) throws InterruptedException
  64. //{
  65. //        DeadLock d1=new DeadLock(false);
  66. //        Thread t1=new Thread(d1);
  67. //        Thread t2=new Thread(d1);
  68. //        t1.start();
  69. //        Thread.sleep(1);
  70. //        d1.setFlag(true);
  71. //        t2.start();
  72. //}
  73.         public static void main(String[] args) throws InterruptedException{
  74.                 Object lock1=new Object();
  75.                 Object lock2=new Object();
  76.                 DeadLock d1=new DeadLock(lock1,lock2);
  77.                 DeadLock d2=new DeadLock(lock1,lock2);
  78.                 d2.setFlag(true);
  79.                 Thread t1=new Thread(d1);
  80.                 Thread t2=new Thread(d2);
  81.                 t1.start();
  82.                 Thread.sleep(1);
  83.                 t2.start();
  84.         }
  85. }

  86. //如果2个Thread里传的是同个线程实现对象 你么你可以不传锁 设计线程实现代码时可以直接用this(不能用在静态成员中)和
  87. //DeadLockDemo.class   如果是不同的实现对象那么就得传入一把锁。
复制代码
回复 使用道具 举报
nailsoul 发表于 2012-5-19 15:00
你也可以只创建一个线程实例  丢进2个线程对象中  这样头前的变量不需要加静态修饰
但是这样就赵成了flag=t ...

哈哈,兄台果然神功盖世!!两种方法都O了!!多谢赐教!!
回复 使用道具 举报
何拴绪 发表于 2012-5-19 14:58
楼主和我有着同样的困惑啊,楼上的说法不是很理解,这个锁是Static的呀 为啥还是出现不了死锁现象呢?  ...

我现在就是出现的这个问题,只执行了else代码块 没有出现死锁, 麻烦您了。。。。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马