1. <p style="line-height: 30px; text-indent: 2em;">class DeadThread {
   
2.         public static String s= "t1";
   
3.         public static String n="t2";//成员变量
   
4.   public static void</font> main(String[] args) {
   
5.                
   
6.                 new Thread("t1"){
   
7.                         public void run(){
   
8.                         while(true)//无线循环
   
9.                                 synchronized(s){
   
10.                                         System.out.println(getName()+"        t1");
    
11.                                                 synchronized(n){//同步锁嵌套
    
12.                                                         System.out.println(getName()+"        t2o");
    
13.                                         }        
    
14.                                 }
    
15.                         }
    
16.                 }.start();
    
17. 
    
18. new Thread("t2"){
    
19.                         public void run(){
    
20.                         while(true)
    
21.                                 synchronized(n){
    
22.                                         System.out.println(getName()+"        t2o");
    
23.                                                 synchronized(s){
    
24.                                                         System.out.println(getName()+"        t1");
    
25.                                                         }
    
26.                                 }
    
27.                         }
    
28.                 }.start();
    
29.         }
    
30. }
    
31. 
    
32. 
    

复制代码

两个线程应该是同时运行的吧？虽然死锁几率比较小，但我打印出来无限循环t1，为什么？

即使造不成死锁，t2总应该一块打印的吧？为什么无限循环t1?并且每次都是打印一次
t2就结束。。。求解。。

我运行了一下你的代码，每次都死锁。
这段代码有三个线程，一个主线程和两个新建的线程。
主线程里面的代码按顺序执行，T1线程比T2线程先创建，所以你的运行结果前面全是T1线程里的。
如果你把T2线程的代码放到T1线程代码前面的话，运行结果会先打印一堆T2线程的内容。

按照你原代码的顺序：T1线程先创建，最先抢到CPU执行权，然后打印一堆内容，然后T1线程又一次循环，它先掌握了它的第一道锁S，但还没来得及打印（或已经打印，但没进入第二道锁），CPU执行权就被T2抢了。因为T2的第一道锁是N，刚刚T1掌握的锁是S，所以T2能抢到N这道锁。
T2线程终于抢到了锁N，打印了一句T2   T20，然后想拿到第二道锁S，但此时S锁还在T1手里拿着，所以T2无法继续执行。T2无法继续执行，就没办法释放锁N。
T1线程想向下继续执行，就需要打开第二道锁N，但此时锁N被T2掌握，所以T1也无法执行。
二者掌握着对方需要的锁不放，造成了死锁。