看了毕老师的多线程死锁，自己也写着玩了一个，可是写出来之后发现好像哪里不对
原谅我是个0基础的渣，对葫芦画板还是不对:'(


//死锁，当有两个锁，互相嵌套时有可能会互相抢夺执行权，出现死锁现象
/*
注意：写死锁是为了避免以后出现死锁！！！！
1：定义两个锁，锁的对象为两个//如何在锁中嵌套另一个锁？？？？？？
2：两个锁的对象分别为对方的锁
*/

class Deathlock implements Runnable
{
        private boolean flag;
//定义锁
        Object obj=new Object();
        Object obje=new Object();
        Deathlock(boolean flag)
        {
                this.flag=flag;
        }
        public void run()
        {
                while(true)
                {
                        if(flag==true)
                        {
                                synchronized(obj)
                                {
                                        System.out.println(Thread.currentThread().getName()+"--obj");
                                        synchronized(obje)
                                        {
                                                System.out.println(Thread.currentThread().getName()+"---obje");
                                        }
                                }
                        }
                        else
                        {
                                synchronized(obje)
                                {
                                        System.out.println(Thread.currentThread().getName()+"---obje");
                                        synchronized(obj)
                                        {
                                                System.out.println(Thread.currentThread().getName()+"--obj");
                                        }
                                }
                       
                        }
                }
        }
}
class DeathlockDemo
{
        public static void main(String[] args)
        {
                Deathlock d=new Deathlock(true);
                Deathlock d1=new Deathlock(false);
                Thread t=new Thread(d);
                Thread t1=new Thread(d1);
                t.start();
                t1.start();
        }
}

楼主，我将你的代码稍加改动，就死锁了。主要改动是将你的两个锁，提取到另一类MyLock中，然后在调用MyLock类中的两个锁


代码如下

1. class Deathlock implements Runnable
   
2. {
   
3.         private boolean flag;
   
4. //定义锁
   
5.        // Object obj=new Object();
   
6.        // Object obje=new Object();
   
7.         Deathlock(boolean flag)
   
8.         {
   
9.                 this.flag=flag;
   
10.         }
    
11.         public void run()
    
12.         {
    
13. 
    
14.                         if(flag)
    
15.                         {
    
16.                                                          while(true)
    
17.                                                          {
    
18.                                 synchronized(MyLock.obj)
    
19.                                 {
    
20.                                         System.out.println(Thread.currentThread().getName()+"--obj");
    
21.                                         synchronized(MyLock.obje)
    
22.                                         {
    
23.                                                 System.out.println(Thread.currentThread().getName()+"---obje");
    
24.                                         }
    
25.                                 }
    
26.                                                          }
    
27.                         }
    
28.                         else
    
29.                         {
    
30.                                                           while(true)
    
31.                                                          {
    
32.                                 synchronized(MyLock.obje)
    
33.                                 {
    
34.                                         System.out.println(Thread.currentThread().getName()+"---obje");
    
35.                                         synchronized(MyLock.obj)
    
36.                                         {
    
37.                                                 System.out.println(Thread.currentThread().getName()+"--obj");
    
38.                                         }
    
39.                                 }
    
40.                                                           }
    
41.                         }
    
42.                
    
43.         }
    
44. }
    
45. 
    
46. class MyLock
    
47. {
    
48.         static Object obj = new Object();
    
49.         static Object obje = new Object();
    
50. }
    
51. 
    
52. 
    
53. class DeathlockDemo02
    
54. {
    
55.         public static void main(String[] args)
    
56.         {
    
57.                 Deathlock d=new Deathlock(true);
    
58.                 Deathlock d1=new Deathlock(false);
    
59.                 Thread t=new Thread(d);
    
60.                 Thread t1=new Thread(d1);
    
61.                 t.start();
    
62.                 t1.start();
    
63.         }
    
64. }
    

复制代码

哥给你分析一下原因，你写的死锁不是死是因为你用的O1，O2这两个对象都不是同一个O1，O2,也就是你在main函数里new线程的时候线程1里的O1,O2跟线程2的O1,O2不是同一个O1,O2。你只要在class Deathlock里new Object对象前加static修饰，保证唯一性，就可锁死

要确保两个线程用的是相同的锁对象才会死锁，自己用自己的锁是没用的

绝望 发表于 2015-3-22 09:57
要确保两个线程用的是相同的锁对象才会死锁，自己用自己的锁是没用的

:handshake谢谢

lzhuas 发表于 2015-3-22 09:50
哥给你分析一下原因，你写的死锁不是死是因为你用的O1，O2这两个对象都不是同一个O1，O2,也就是你在main函 ...

好高深的样子，谢谢了

coolzhou9527 发表于 2015-3-22 01:41
楼主，我将你的代码稍加改动，就死锁了。主要改动是将你的两个锁，提取到另一类MyLock中，然后在调用MyLock ...

谢谢了，会努力的:D

都是大神啊

来学习了

xiaogougou 发表于 2015-3-24 00:08
都是大神啊

我是渣来的

胡谭龙 发表于 2015-3-24 16:17
来学习了

;P共同学习

coolzhou9527 发表于 2015-3-22 01:41
楼主，我将你的代码稍加改动，就死锁了。主要改动是将你的两个锁，提取到另一类MyLock中，然后在调用MyLock ...

:handshake好厉害，谢谢