1. 
   
2. public class DeadLock implements Runnable {
   
3.         Object locka=new Object();
   
4.         Object lockb=new Object();
   
5.         @Override
   
6.         public void run() {
   
7.         while(true){
   
8.                 synchronized (locka) {
   
9.                         System.out.println("11locka");
   
10.                         synchronized (lockb) {
    
11.                                 System.out.println("11lockb");
    
12.                         }
    
13.                 }
    
14.                 synchronized (lockb) {
    
15.                 System.out.println("22lockb");
    
16.                 synchronized (locka) {
    
17.                         System.out.println("22locka");
    
18.                 }
    
19.                 }
    
20.         }
    
21. 
    
22.         }
    
23. }
    
24. 
    
25. public class Test {
    
26. 
    
27.         public static void main(String[] args) {
    
28.                 DeadLock dk=new DeadLock();
    
29.                 Thread t1=new Thread(dk,"aa");
    
30.                 Thread t2=new Thread(dk,"bb");
    
31.                 t1.start();
    
32.                 t2.start();        
    
33.         }
    
34. }
    
35. 这样也可以死锁，但是在while里面线程为什么可以直接去走第二个锁

复制代码

应该是第一线程去一个锁走出来了 然后进了第二个锁 然后 第二个说又进来了 进了第一个锁吧

稍微修改了下输出语句,为了看的直观一点
输出结果:
Thread[t1,5,main]---------|11locka
Thread[t1,5,main]---------|11lockb
Thread[t1,5,main]---------|22lockb
Thread[t2,5,main]---------|11locka


当t1线程执行完while中的
synchronized (locka) {
                        System.out.println(Thread.currentThread()+"---------|"+"11locka");
                        synchronized (lockb) {
                                System.out.println(Thread.currentThread()+"---------|"+"11lockb");
                        }
                }
执行完毕后 释放了 locka 和lockb

进入了 synchronized (lockb) {
                System.out.println(Thread.currentThread()+"---------|"+"22lockb");
               //执行到这里时 t2线程进入while 执行的第一部分 t1持有lockb 请求locka  t2持有locka 请求lockb 所以发生死锁
                synchronized (locka) {
                        System.out.println(Thread.currentThread()+"---------|"+"22locka");
                }
}