如题：得到一个一个简单的死锁程序，最主要的是可以透过程序的死锁原因。

1. class Dead implements Runnable  
   
2. {  
   
3.     public boolean flag;  
   
4.     public Object locka=new Object();  
   
5.     public Object lockb=new Object();  
   
6.     public Dead(boolean f) {this.flag=f;}  
   
7.     public void run()  
   
8.   
   
9.     {  
   
10.          while(true) {  
    
11.                 if(flag)  
    
12.                 {  
    
13.                     synchronized(Lock.locka)  
    
14.                     {  
    
15.                         System.out.println("if loca");  
    
16.                         synchronized(Lock.lockb)  
    
17.                         {  
    
18.                             System.out.println("if lockb");  
    
19.                         }  
    
20.                     }  
    
21.                 }  
    
22.                      
    
23.                 else {  
    
24.                     synchronized(Lock.lockb)  
    
25.                     {  
    
26.                         System.out.println("else lockb");  
    
27.                         synchronized (Lock.locka) {  
    
28.                             System.out.println("else locka");  
    
29.                         }  
    
30.                     }  
    
31.                 }  
    
32.             }  
    
33.     }  
    
34. }  
    
35. class Lock  
    
36. {  
    
37.     static Object locka=new Object();  
    
38.     static Object lockb=new Object();  
    
39. }  
    
40. public class DeadLock {  
    
41.   
    
42.     public static void main(String args[])  
    
43.     {  
    
44.         Thread t1=new Thread(new Dead(true));  
    
45.         Thread t2=new Thread(new Dead(false));  
    
46.         t1.start();  
    
47.         t2.start();  
    
48.     }  
    
49. }  

复制代码

结果:

/*
*                          写一个死锁程序
*              容易引起 是因为两个锁引用的不是同一个锁，这样就会引起死锁现在
*
*              还有在多现在中出现安全性问题的时候，一般要考虑的问题：
*              1.   是不是两个线程,并且两个线程有没有同步,也就是有没有 synchronized 块或函数
*              2.   如果有多个同步代码块或同步函数的话,那看看所有 的同步它们用的是不是同一个锁,如果不是,会引起死锁和安全性问题
*
* */

1. class DeadLock implements Runnable {
   
2.         boolean flag;
   
3. 
   
4.         DeadLock(boolean flag) {
   
5.                 this.flag = flag;
   
6.         }
   
7. 
   
8.         public void run() {
   
9.                 if (flag) {
   
10.                         while (true) {
    
11.                                 synchronized (TwoLocks.lock1) {
    
12.                                         System.out.println("if get lock1");
    
13.                                         synchronized (TwoLocks.lock2) {
    
14.                                                 System.out.println("if get lock2");
    
15.                                         }
    
16.                                 }
    
17.                         }
    
18.                 } else {
    
19.                         while (true) {
    
20.                                 synchronized (TwoLocks.lock2) {
    
21.                                         System.out.println("else get lock2");
    
22.                                         synchronized (TwoLocks.lock1) {
    
23.                                                 System.out.println("else get lock1");
    
24.                                         }
    
25.                                 }
    
26.                         }
    
27.                 }
    
28.         }
    
29. }
    
30. 
    
31. class TwoLocks {
    
32.         public static Object lock1 = new Object();
    
33.         public static Object lock2 = new Object();
    
34. }
    
35. 
    
36. public class Test {
    
37.         public static void main(String[] args) throws InterruptedException {
    
38.                 new Thread(new DeadLock(true)).start();
    
39.                 new Thread(new DeadLock(false)).start();
    
40.         }
    
41. 
    
42. }

复制代码

msileandroid 发表于 2013-5-29 21:18
结果:

/*

谢谢我懂了，很好很强大