多线程并发执行时如何避免死锁

同步或加群

张鹏宇 发表于 2014-5-19 12:07
同步或加群

加锁。。。错字。好尴尬，等一分钟才能发出去。

学习一下。。。。。。。。。。。。。。。。。

张鹏宇 发表于 2014-5-19 12:07
同步或加群

哥们，同步才有的锁啊，你这说的都点矛盾哦

对于死锁，我们首先明确什么是死锁，然后再避免如何遇到死锁呢。
首先死锁的前提
1. 同步嵌套
2.嵌套的同步持有不同的锁
代码示例：

1. class Test
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Thread t1 = new Thread(new Demo(true));
   
6.                 Thread t2 = new Thread(new Demo(false));
   
7.                 t1.start();
   
8.                 t2.start();
   
9. 
   
10.         }
    
11. }
    
12. class Demo implements Runnable
    
13. {
    
14.         private boolean flag;
    
15.         Demo(boolean flag)
    
16.         {
    
17.                 this.flag=flag;
    
18.         }
    
19.         public void run()
    
20.         {
    
21.                 if(flag)
    
22.         {
    
23.                 while(flag==true)
    
24.                 {
    
25.                 synchronized(Demo2.obja)//它的锁是obja
    
26.                 {
    
27.                         System.out.println("if-----obja");
    
28.                         synchronized(Demo2.objb)//它的锁是objb
    
29.                         {
    
30.                                 System.out.println("if-----obja");
    
31.                         }
    
32.                 }
    
33.                 }
    
34.         }
    
35.         else
    
36.         {
    
37.                 while(flag==false)
    
38.                 {
    
39.                 synchronized(Demo2.objb)//它的锁是objb
    
40.                 {
    
41.                         System.out.println("else-----obja");
    
42.                         synchronized(Demo2.obja)//它的锁是obja
    
43.                         {
    
44.                                 System.out.println("else-----objb");
    
45.                        
    
46.                         }
    
47.                 }
    
48.                 }
    
49.         }
    
50.         }
    
51.        
    
52. }
    
53. class Demo2
    
54. {
    
55.         //定义两个锁
    
56.         static Object obja = new Object();
    
57.         static Object objb = new Object();
    
58. }

复制代码

这段代码就是个典型的死锁，线程在抢夺CPU的执行权的时候，就会发生你要的锁，我也想要你的锁，但是谁也不给谁，这就造成了死锁，只要把锁给变成同一把锁就哦了，所以多了就容易分不清出现死锁现象！！

格子、 发表于 2014-5-19 16:02
哥们，同步才有的锁啊，你这说的都点矛盾哦

就是syc 和 locked阿