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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

  1. class Demo implements Runnable
  2. {
  3.         private boolean flag;
  4.         Object locka = new Object();
  5.         Object lockb = new Object();
复制代码
我把死锁需要的两个对象建在了Demo类里面,怎么运行都不会死锁,而老毕是这样做的
  1. class MyLock
  2. {
  3.         static Object locka = new Object();
  4.         static Object lockb = new Object();
  5. }
复制代码
他又写了一个类,运行的时候才会死锁,而且只能打印两行代码。

完整代码见2楼、三楼

评分

参与人数 1技术分 +1 收起 理由
杨佳名 + 1 淡定

查看全部评分

12 个回复

正序浏览
本帖最后由 奋斗的蜗牛ksd 于 2014-11-19 13:03 编辑
聪明叉 发表于 2014-11-19 07:33
但是老毕那个不一样,必然运行两行停止,你试试就知道了。

老毕的代码你指的是那一个??我运行楼上仁兄的代码也一直是两行~,你跟老毕的代码没什么区别的。。
老毕的本意只是写个死锁的程序,同步嵌套而已,老毕视频里不让在本类创建对象的--明明注释了~他们照抄了肯定错了
回复 使用道具 举报
哥们,你那个资源对象有两个,那么锁对像就会不一样:
Thread t1 = new Thread(new Test(true));
Thread t2 = new Thread(new Test(false));

new Test();进行了两次
回复 使用道具 举报
聪明叉 来自手机 中级黑马 2014-11-19 07:33:30
11#
奋斗的蜗牛ksd 发表于 2014-11-18 21:26
死锁不是绝对的啊,看cpu,,,和人品。。有可能出和谐状态的

但是老毕那个不一样,必然运行两行停止,你试试就知道了。
回复 使用道具 举报
老毕那个代码写错了,这个问题好几个人问过了
回复 使用道具 举报
聪明叉 发表于 2014-11-18 21:09
明白了,但是老毕那个为什么只能运行两行呢?必然死锁

死锁不是绝对的啊,看cpu,,,和人品。。有可能出和谐状态的
回复 使用道具 举报
hailong 中级黑马 2014-11-18 21:14:37
8#
我是这样写的死锁
  1. public class Test1 {
  2.         public static void main(String[] args) {
  3.                 DeadLock dl1 = new DeadLock(true);
  4.                 DeadLock dl2 = new DeadLock(false);
  5.                 new Thread(dl1).start();
  6.                 new Thread(dl2).start();
  7.         }
  8. }
  9. class DeadLock implements Runnable{
  10.         private boolean flag;
  11.         DeadLock(boolean flag){
  12.                 this.flag = flag;
  13.         }
  14.         public void run(){
  15.                 if(flag){
  16.                         synchronized(LockA.locka){
  17.                                 System.out.println("if...locka");
  18.                                 synchronized(LockB.lockb){
  19.                                         System.out.println("if...lockb");
  20.                                 }
  21.                         }
  22.                 }else{
  23.                         synchronized(LockB.lockb){
  24.                                 System.out.println("else...lockb");
  25.                                 synchronized(LockA.locka){
  26.                                         System.out.println("else...locka");
  27.                                 }
  28.                         }
  29.                 }
  30.         }
  31. }
  32. class LockA{
  33.         public static final LockA locka = new LockA();
  34. }
  35. class LockB{
  36.         public static final LockB lockb = new LockB();
  37. }
复制代码


回复 使用道具 举报
奋斗的蜗牛ksd 发表于 2014-11-18 21:08
这个问题我回答过三遍了,,,
建议多看看前面的帖子。

没那么时间逛论坛啊,有问题解决不了才回来一下
回复 使用道具 举报
奋斗的蜗牛ksd 发表于 2014-11-18 21:06
兄弟,我觉得你是匿名对象没有搞懂,
Thread t1 = new Thread(new Test(true));
new Test()这是一个匿名对 ...

明白了,但是老毕那个为什么只能运行两行呢?必然死锁
回复 使用道具 举报
这个问题我回答过三遍了,,,
建议多看看前面的帖子。
回复 使用道具 举报
本帖最后由 奋斗的蜗牛ksd 于 2014-11-18 21:07 编辑

兄弟,我觉得你是匿名对象没有搞懂,
Thread t1 = new Thread(new Test(true));
new Test()这是一个匿名对象,启动匿名对象之前得先加载Test类把,,而你在Test类中写了下面这两句话
Object obj1 = new Objet();
Object obj2 = new Objet();
意思就是 一个new Test(true)有两把锁 一个 叫obj1  一个叫obj2
Thread t2 = new Thread(new Test(false));
同理 new Test(false)对象 这个家伙也有两把锁,名字也叫一个 叫obj1  一个叫obj2
对应的俩线程 t1
t2 各自有两把名字一样的锁,你说t1访问的时候 能不能锁住t2呢?

评分

参与人数 1技术分 +1 收起 理由
杨佳名 + 1 赞一个!

查看全部评分

回复 使用道具 举报
老毕的完整代码是这样的


  1. class Test implements Runnable
  2. {
  3.         private boolean flag;
  4.         Test(boolean flag)
  5.         {
  6.                 this.flag = flag;
  7.         }

  8.         public void run()
  9.         {
  10.                 if(flag)
  11.                 {
  12.                         while(true)
  13.                         {
  14.                                 synchronized(MyLock.locka)
  15.                                 {
  16.                                         System.out.println(Thread.currentThread().getName()+"...if locka ");
  17.                                         synchronized(MyLock.lockb)
  18.                                         {
  19.                                                 System.out.println(Thread.currentThread().getName()+"..if lockb");                                       
  20.                                         }
  21.                                 }
  22.                         }
  23.                 }
  24.                 else
  25.                 {
  26.                         while(true)
  27.                         {
  28.                                 synchronized(MyLock.lockb)
  29.                                 {
  30.                                         System.out.println(Thread.currentThread().getName()+"..else lockb");
  31.                                         synchronized(MyLock.locka)
  32.                                         {
  33.                                                 System.out.println(Thread.currentThread().getName()+".....else locka");
  34.                                         }
  35.                                 }
  36.                         }
  37.                 }
  38.         }
  39. }


  40. class MyLock
  41. {
  42.         static Object locka = new Object();
  43.         static Object lockb = new Object();
  44. }

  45. class  DeadLockTest
  46. {
  47.         public static void main(String[] args)
  48.         {
  49.                 Thread t1 = new Thread(new Test(true));
  50.                 Thread t2 = new Thread(new Test(false));
  51.                 t1.start();
  52.                 t2.start();
  53.         }
  54. }
复制代码



回复 使用道具 举报
本帖最后由 聪明叉 于 2014-11-18 21:06 编辑

这是我的完整代码
  1. class Demo implements Runnable
  2. {
  3.         private boolean flag;
  4.         Object locka = new Object();
  5.         Object lockb = new Object();
  6.        
  7.         public Demo(boolean flag)
  8.         {
  9.                 this.flag = flag;
  10.         }

  11.         public void run()
  12.         {
  13.                 if(flag)
  14.                 {
  15.                         while (true)
  16.                         {
  17.                                 synchronized(this)
  18.                                 {
  19.                                         System.out.println("if locka");
  20.                                         synchronized(locka)
  21.                                         {
  22.                                                 System.out.println("if lockb");
  23.                                         }
  24.                                 }
  25.                         }
  26.                 }
  27.                 else
  28.                 {
  29.                         while(true)
  30.                         {
  31.                                 synchronized(locka)
  32.                                 {
  33.                                         System.out.println("else lockb");
  34.                                         synchronized(this)
  35.                                         {
  36.                                                 System.out.println("else locka");
  37.                                         }
  38.                                 }
  39.                         }
  40.                 }
  41.         }
  42. }



  43. class LockDemo
  44. {
  45.         public static void main(String[] args)
  46.         {
  47.                 Thread t1 = new Thread(new Demo(true));
  48.                 Thread t2 = new Thread(new Demo(false));

  49.                 t1.start();
  50.                 t2.start();

  51.         }
  52. }
复制代码



回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马