黑马程序员———死锁

死锁：同步中嵌套同步
进程A占有资源R1，等待进程B占有的资源Rr；进程B占有资源Rr，等待进程A占有的资源R1。而且资源R1和Rr只允许一个进程占用，即：不允许两个进程同时占用。结果，两个进程都不能继续执行，若不采取其它措施，这种循环等待状况会无限期持续下去，就发生了进程死锁。  
简单点说：有A和B两个线程，有CD 两把锁， A和B嵌套CD锁，A线程中有C，D锁，B线程中有D C两把锁，而且AB两线程不能同时获得C或D锁，当两个线程运行时，就可能会出现死锁导致
，有关死锁代码是毕老师交代必须会自己写的代码

1. package com.itheima;
   
2. 
   
3. class Deadlock  implements Runnable
   
4. {
   
5.         private boolean flag ;
   
6.         
   
7.         Deadlock(boolean flag)
   
8.         {
   
9.                 this.flag = flag;
   
10.         }
    
11.         
    
12.         @Override
    
13.         public void run()
    
14.         {
    
15.                 if(flag)
    
16.                 {
    
17.                         while(true)
    
18.                         {
    
19.                                 synchronized (DeadlockT.locka)
    
20.                                 {
    
21.                                         System.out.println("if locha");
    
22.                                         synchronized (DeadlockT.lockb)
    
23.                                         {
    
24.                                                 System.out.println("if lockb");
    
25.                                         }                                        
    
26.                                 }                                
    
27.                         }
    
28.                         
    
29.                 }else
    
30.                 {
    
31.                         while(true)
    
32.                         {
    
33.                                 synchronized (DeadlockT.lockb)
    
34.                                 {
    
35.                                         System.out.println("else lockb");
    
36.                                         synchronized (DeadlockT.locka)
    
37.                                         {
    
38.                                                 System.out.println("else locka");
    
39.                                         }
    
40.                                         
    
41.                                 }
    
42.                         }
    
43.                                                         
    
44.                 }                                
    
45.         }        
    
46. }
    
47. 
    
48. class DeadlockT
    
49. {
    
50.         static Object locka = new Object();
    
51.         static Object lockb = new Object();
    
52. }
    
53. 
    
54. class DeadlockTest
    
55. {
    
56.         public static void main(String[] args)
    
57.         {
    
58.                 Thread t1 = new Thread(new Deadlock(true));
    
59.                 Thread t2 = new Thread(new Deadlock(false));
    
60.                 t1.start();
    
61.                 t2.start();
    
62.         }        
    
63. }

复制代码