1. /*写个死锁*/
   
2. 
   
3. class Test implements Runnable
   
4. {
   
5.         private boolean flag;
   
6.         Test(boolean flag)
   
7.         {
   
8.                 this.flag = flag;
   
9.         }
   
10.         public void run()
    
11.         {
    
12.                 if(flag)
    
13.                 {
    
14.                         while(true){
    
15.                         synchronized(MyLock.locka)
    
16.                         {
    
17.                                 System.out.println("if locka");
    
18.                                 synchronized(MyLock.lockb)
    
19.                                 {
    
20.                                         System.out.println("if lockb");
    
21. 
    
22.                                 }
    
23.                         }}
    
24.                 }
    
25.                 else
    
26.                 {
    
27.                         while(true){
    
28.                         synchronized(MyLock.lockb)
    
29.                         {
    
30.                                 System.out.println("else lockb");
    
31.                                 synchronized(MyLock.locka)
    
32.                                 {
    
33.                                         System.out.println("else locka");
    
34. 
    
35.                                 }
    
36.                         }}
    
37.                 }
    
38. 
    
39.         }
    
40. }
    
41. class MyLock
    
42. {
    
43.         static Object locka = new Object();
    
44.         static Object lockb = new Object();
    
45. }
    
46. class DeadLockDemo
    
47. {
    
48.         public static void main(String[] args)
    
49.         {
    
50.                 Thread t1 = new Thread(new Test(true));//Test类又不是单例，这里不是创建了两个
    
51.                 Thread t2 = new Thread(new Test(false));//对象吗，为啥会有死锁呢，难道在线程里创建对象都是创建的同一个对象吗？
    
52.                 t1.start();
    
53.                 t2.start();
    
54.         }
    
55. }

复制代码

在函数中Test类又不是单例，这里不是创建了两个对象吗，为啥会有死锁呢，难道在线程里创建对象都是创建的同一个对象吗？

死锁：通常是同步中嵌套同步产生，理解了死锁出现的原因就明白了，
线程是创建了两个Thread t1 = new Thread(new Test(true));
                Thread t2 = new Thread(new Test(false));
对象是两个new Test(false)和new Test(true)但是锁只有两个，locka和lockb因为class MyLock中这两个所都是静态的，静态的是所有对象共享数据。
不管几个对象。他们用的都是这两把锁，所以在嵌套同步中出现死锁
如果你把locka和lockb定义成非静态的，在Test中new个对象，用对象调用，就不会出现死锁了，因为这时是四个锁了，同时这两个线程也不是同步了，不满足同步条件了
同步的前提：
1.必须要有两个或以上的线程
2.必须是多个线程使用同一个锁