1. package com.sergio.Thread;
   
2. /**
   
3. * @ClassName: DeadLock
   
4. * @Description: 有两个对象a、b，有两个线程t1、t2。t1去锁a，同时t2去锁b；而同时t1又想去锁b，t2对象b的锁还没释放，t2又想去锁a，而t1对a的锁还没释放，最终造成死锁
   
5. * @author Sergio Han
   
6. * @date 2013-8-7 上午12:08:29
   
7. *
   
8. */
   
9. 
   
10. public class DeadLock {
    
11. 
    
12.         public static void main(String[] args) {
    
13.                 //创建两个对象
    
14.                 Object o1 = new Object();
    
15.                 Object o2 = new Object();
    
16.                
    
17.                 //创建两个线程
    
18.                 Thread t = new Thread(new T1(o1, o2));
    
19.                 Thread t2 = new Thread(new T2(o1, o2));
    
20.                
    
21.                 //启动
    
22.                 t.start();
    
23.                 t2.start();
    
24.         }
    
25. }
    
26. 
    
27. class T1 implements Runnable {
    
28.         //声明两个对象变量o1、o2
    
29.         Object o1;
    
30.         Object o2;
    
31.         //构造方法
    
32.         T1(Object o1, Object o2)
    
33.         {
    
34.                 this.o1 = o1;
    
35.                 this.o2 = o2;
    
36.         }
    
37.        
    
38.         //重写run方法
    
39.         public void run() {
    
40.                 //锁o1对象的锁
    
41.                 synchronized(o1)
    
42.                 {
    
43.                         try {
    
44.                                 //让t1线程休眠1秒
    
45.                                 Thread.sleep(1000);
    
46.                         } catch (InterruptedException e) {
    
47.                                 // TODO Auto-generated catch block
    
48.                                 e.printStackTrace();
    
49.                         }
    
50.                         //锁o2对象的锁
    
51.                         synchronized (o2) {
    
52.                                 System.out.println("asfsf");
    
53.                         }
    
54.                 }
    
55.         }
    
56. }
    
57. 
    
58. class T2 implements Runnable {
    
59.        
    
60.         //声明两个对象变量o1、o2
    
61.         Object o1;
    
62.         Object o2;
    
63.         //构造函数
    
64.         T2(Object o1, Object o2)
    
65.         {
    
66.                 this.o1 = o1;
    
67.                 this.o2 = o2;
    
68.         }
    
69.         public void run() {
    
70.                 //锁o2对象的锁
    
71.                 synchronized (o2) {
    
72.                         try {
    
73.                                 //让t2线程休眠1秒，防止没锁上
    
74.                                 Thread.sleep(1000);
    
75.                         } catch (InterruptedException e) {
    
76.                                 // TODO Auto-generated catch block
    
77.                                 e.printStackTrace();
    
78.                         }
    
79.                         //锁o1对象的锁
    
80.                         synchronized (o1) {
    
81.                                 System.out.println("b");
    
82.                         }
    
83.                 }
    
84.         }
    
85. }
    

复制代码

有没有更简单的写法？

暂时还没想到怎么写