1. public class TestDeathlock {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 DeathLock dl1 = new DeathLock(true);
   
8.                 DeathLock dl2 = new DeathLock(false);
   
9.                 Thread thread1 = new Thread(dl1);
   
10.                 Thread thread2 = new Thread(dl2);
    
11.                 thread1.start();
    
12.                 thread2.start();
    
13. 
    
14.         }
    
15. 
    
16. }
    
17. 
    
18. class DeathLock implements Runnable{
    
19.         private boolean b ;
    
20.         DeathLock(Boolean b){
    
21.                 this.b = b;
    
22.         }
    
23.         static Object o1=new Object();
    
24.         static Object o2=new Object();
    
25.        
    
26.         @Override
    
27.         public void run() {
    
28.                 if(b){
    
29.                         synchronized (o1) {
    
30.                                 try {
    
31.                                         Thread.sleep(500);
    
32.                                 } catch (InterruptedException e) {
    
33.                                         // TODO Auto-generated catch block
    
34.                                         e.printStackTrace();
    
35.                                 }
    
36.                         }
    
37.                         synchronized (o2) {
    
38.                                 System.out.println("这里是b为true的");
    
39.                         }
    
40.                 }
    
41.                 if(!b){
    
42.                         synchronized (o2) {
    
43.                                 try {
    
44.                                         Thread.sleep(500);
    
45.                                 } catch (InterruptedException e) {
    
46.                                         // TODO Auto-generated catch block
    
47.                                         e.printStackTrace();
    
48.                                 }
    
49.                         }
    
50.                         synchronized (o1) {
    
51.                                 System.out.println("这里是b为false的");
    
52.                         }
    
53.                        
    
54.                 }
    
55.         }
    
56.        
    
57. }

复制代码

两句都能打印，是怎么回事呢？

以一手交钱一手交货比喻，而现在两个人互不信任，A拿着货想让B把钱先给自己，而B拿着钱想让A把货先给自己，最终造成：死锁。

应该将代码改成下面格式：
synchronized (o1)
{
   synchronized (o2) {}
}

刘基军 发表于 2012-3-6 11:28
以一手交钱一手交货比喻，而现在两个人互不信任，A拿着货想让B把钱先给自己，而B拿着钱想让A把货先给自己， ...

哦哦 是啊 哈哈 确实是包含方式！！