请大家帮忙看下，这个程序怎么会出现死锁呢？

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("if locka");
    
15. 　　 synchronized(MyLock.lockb)
    
16. 　　 {
    
17. 　　 System.out.println("if lockb");
    
18. 　　 }
    
19. 　　 }
    
20. 　　 }
    
21. 　　 else
    
22. 　　 {
    
23. 　　 synchronized(MyLock.lockb)
    
24. 　　 {
    
25. 　　 System.out.println("else lockb");
    
26. 　　 synchronized(MyLock.locka)
    
27. 　　 {
    
28. 　　 System.out.println("else locka");
    
29. 　　 }
    
30. 　　 }
    
31. 　　 }
    
32. 　　 }
    
33. 　　}
    
34. 　　class MyLock
    
35. 　　{
    
36. 　　 static Object locka=new Object();
    
37. 　　 static Object lockb=new Object();
    
38. 　　
    
39. 　　}
    
40. 　　class DeadLockTest
    
41. 　　{
    
42. 　　 public static void main(String[] args)
    
43. 　　 {
    
44. 　　 Thread t1=new Thread(new Test(true));
    
45. 　　 Thread t2=new Thread(new Test(false));
    
46. 　　 t1.start();
    
47. 　　 t2.start();
    
48. 　　 }
    
49. 　　}

复制代码

程序中，有两句代码：

Thread t1=new Thread(new Test(true));

Thread t2=new Thread(new Test(false));

这不是相当于创建了两个Test对象吗？并且创建了两个线程分别来执行两个Test对象中run中的代码吗？
那么这两个对象都是独立的，它们又没有联系，自己的线程执行自己run中的代码，那又怎么会出现死锁呢？

嗯，是这样的，方法是独立的，资源也是各自的，但是，出现死锁的前提是访问目标被synchornized修饰了的，synchornized修饰之后，这个资源就被所有对象全部共享了，就好比每个人手里都有一碗饭，但是筷子只有一双，只能一个人吃一口自己碗里的饭，但是如果饭被synchornied修饰了，就代表着，大家都把饭倒进了一个桶里，排着队大家一口一口的吃，此时，这桶饭就是共享资源，也就是临界资源，但是如果一个人吃着吃着(sleep())睡着了，其他的人也只有等着了，这就是死锁

一段代码只要有synchronized，同一时间就只能被一个线程访问，出现死锁应该是线程1持有锁1，线程2持有锁2，两个线程各持有一个锁，所以执行不下去。这段代码应该是故意要死锁的，这样写。

希望你能理解！

我是这么理解的 当一个线程执行到synchronized之后 相当于拿到了锁 只要对应的那段程序没运行完 就会一直拿着 你这段程序中 当线程1执行到了locka时 线程1就拿到了locka 接下来他要往下执行就需要拿到lokb 而正好这个时候线程2拿到了lockb 线程2想要继续就要locka    这个时候就发生了一个很有趣的现象 就是线程1管线程2要lockb  线程2管线程1要locka  这样两个线程都拿不到自己想要的锁 就成了死锁。

谢谢各位了！