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

复制代码

和 造成这两种死锁的流程能不能讲解一下？

嗯懂了些

在main线程中启动了线程0和线程1，线程0和线程1优先级一样，在start()之后都有机会运行，
如果线程0先运行，则线程0先拿到MyLock.locka锁，打印...if locka，之后线程0继续运行，要想进入下一层，他必须拿到MyLock.lockb锁，
这时线程1刚好抢到CPU执行权，启动，线程1拿到了MyLock.lockb锁，打印...else lockb,线程1想进第二层，则需要拿到MyLock.locka锁，而这个锁在线程0手里，线程0还没有执行完毕，不会放锁，他需要线程1的锁，线程1也没有执行完，不会放锁，于是出现死锁。
如果线程1先运行，按上述分析，会先打印...else lockb，再打印...if locka，然后出现死锁

因为Object locka  = new Object() ,lockb  = new Object();   加上static修饰以后，locka 和lockb变

成静态。
由于static 的变量所有的调用都是同一块内存（同一个进程），所以两个线程所需要的

变量是一样的，那么这两个变量学名上是临介资源，一次只能给一个进程服务；
当线程1运行时，需要locka 变量，此时他取得locka 变量然后sleep一段时间 ，之后在线程

1sleep这段时间，线程2取得变量lockb，然后sleep一段时间 ，线程1sleep结束后，申请

变量lockb，由于线程2正控制变量lockb，所以线程1无法取得，此时线程1等待线程2释放变

量lockb，线程1等待时未释放变量locka   ，线程2sleep结束后，申请变量locka ，由于线程1正

控制变量locka ，所以线程2无法取得，此时线程2等待线程1释放变量locka ,线程2等待时未释

放变量lockb   ，死锁出现了，两者都需要两个变量，而手里只有一个，等另一个，在手

的又不放，则不会有一个线程能执行下去，两个就永远的这么死下去；如没有两个

static变量，就不存在资源的抢夺，出现不了死锁；死锁必须存在一个以上的临介资源