1. new Thread(new Runnable() {
   
2. 
   
3.                         @Override
   
4.                         public void run() {
   
5.                                 while (true) {
   
6.                                 //22222222
   
7.                                         System.out.println(Thread.currentThread().getName()
   
8.                                                         + "thread ...");
   
9.                                 }
   
10. 
    
11.                         }
    
12.                 }) {
    
13.                         @Override
    
14.                         public void run() {
    
15.                                 while (true) {
    
16.                                 //1111
    
17.                                         try {
    
18.                                                 Thread.sleep(10);
    
19.                                         } catch (InterruptedException e) {
    
20.                                                 // TODO Auto-generated catch block
    
21.                                                 e.printStackTrace();
    
22.                                         }
    
23.                                         System.out.println(Thread.currentThread().getName()
    
24.                                                         + "haha");
    
25.                                 }
    
26.                         }
    
27. 
    
28.                 }.start();

复制代码

我知道结果是执行11111处的代码，该怎么解析呢？

问老师，还是发帖子问大家把，论坛上高手如云。。。

class Test{
        public static void main(String[] args) {
                        new Thread(new Runnable() {//通过Runnable内部类来创建线程，重写run方法
       
                    @Override
                    public void run() {
                            while (true) {//死循环
                            //22222222
                                    System.out.println(Thread.currentThread().getName()
                                                    + "thread ...");
                            }
       
                    }
            }) //标号（1）
                       
                        {
                    @Override
                    public void run() {
                            while (true) {
                            //1111
                                    try {
                                            Thread.sleep(10);
                                    } catch (InterruptedException e) {
                                            // TODO Auto-generated catch block
                                            e.printStackTrace();
                                    }
                                    System.out.println(Thread.currentThread().getName()
                                                    + "haha");
                            }
                    }
       
            }.start();//标号（2）                启动线程
               
        }
}
我加了一些注释，里面有两个标号，如果你把调用线程放在标号（1）的位置，那么执行的是第一个run方法的内容，如果放在标号（2）的位置，也就是你这个程序，执行的就是第二个run方法的内容，至于这种两个run方法的，我还真没见过，你问下老师吧