a

1. /**
   
2. *        死锁演示
   
3. */
   
4. 
   
5. public class DeadLock implements Runnable {
   
6.         private Object objA = new Object();
   
7.         private Object objB = new Object();//锁对象
   
8.         private boolean flag = false;
   
9.        
   
10. //        DeadLock(boolean b){
    
11. //                this.flag = b;
    
12. //        }
    
13.         @Override
    
14.         public void run() {
    
15.                 // 相互嵌套是锁，可能会出现互相等待的现象导致死锁
    
16.                 while(true){
    
17.                         if(flag){
    
18.                                 synchronized(objA){//嵌套锁
    
19.                                         System.out.println("if A..."+Thread.currentThread().getName());
    
20.                                         synchronized(objB){
    
21.                                                 System.out.println("if B..."+Thread.currentThread().getName());
    
22.                                         }
    
23.                                         flag = flag^true; //flag取反
    
24.                                 }
    
25.                         }else{
    
26.                                 synchronized(objB){//嵌套锁
    
27.                                         System.out.println("else A..."+Thread.currentThread().getName());
    
28.                                         synchronized(objA){
    
29.                                                 System.out.println("else B..."+Thread.currentThread().getName());
    
30.                                                                                                                                                                        
    
31.                                         }
    
32.                                         flag = flag^true;  //flag取反
    
33.                                 }
    
34.                         }
    
35.                 }
    
36.                
    
37.         }
    
38. }
    

复制代码

1. 
   
2. public class DeadLockTest {
   
3. 
   
4.         /**
   
5.          * 用于死锁的测试
   
6.          */
   
7.         public static void main(String[] args) {
   
8.                 // TODO Auto-generated method stub
   
9.                 //建立资源对象
   
10.                 DeadLock d1 = new DeadLock();
    
11.                 //新建两个进程
    
12.                 new Thread(d1,"线程1").start();
    
13.                 new Thread(d1,"线程2").start();
    
14.         }
    
15. 
    
16. }
    

复制代码

运行结果

1. else A...线程1         //线程1 进入else，获取锁B
   
2. else B...线程1     
   
3. if A...线程1     //线程1执行完else，释放B锁,进入if，获取锁A，在等待获取B锁
   
4. else A...线程2        //线程2 持有B锁，在等待A锁
   
5. //此时出现互相等待，即死锁现象，程序无法继续运行

复制代码