锁1{  锁2{ }   }

   锁2{  锁1{ }   }

同步内嵌套同步就会产生死锁的情况

差不多，但并不是一定会出现死锁，加个while(true)的话就一定会出现死锁了。。

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

复制代码

代码如上，如果仅仅是嵌套有时候锁不上，需要加上while（true），就一定能锁上了，这个算是比较简单的锁了！

产生死锁的原因主要有:
1、临界资源使用的互斥性
一个资源每次只能给一个进程使用
2、部分地分配资源.  
一个进程在申请新的资源的同时保持对原有资源的占有（只有这样才是动态申请，动态分配）
3、资源的循环等待.
存在一个进程等待队列 {P1 , P2 , … , Pn},其中P1等待P2占有的资源,P2等待P3占有的资源…Pn等待P1占有的资源,形成一个进程等待环路
4、资源的不可抢占性等.
资源申请者不能强行的从资源占有者手中夺取资源，资源只能由占有者自愿释放

说是原因,也可以称为前提... 4条都满足才会发生死锁

看了楼上的解释我也明白了

感谢楼上解析，受教了哈