问题出在这。class Ticket extends Thread implements Runnable
首先这是对线程定义的两种方式，使用一个即可。没必要既继承有实现。
然后问题出在你对构造函数初始化时，因为接口中没有构造函数，所以这个super()语句初始化的是Thread类中的，而你在主函数中定义的线程是使用接口方式执行的，那么创建线程时候传入的参数默认为是Runnable接口的子类，不能有自定义的名字，所以打印的结果还是线程原名。
可将主函数内改写成这样的形式:

1. Ticket t_1 = new Ticket("one");
   
2.                    Ticket t_2 = new Ticket("two");
   
3.                    Ticket t_3 = new Ticket("three");
   
4.                    Ticket t_4 = new Ticket("four");
   
5.                    t_1.start();
   
6.                    t_2.start();
   
7.                    t_3.start();
   
8.                    t_4.start();

复制代码

王磊 发表于 2013-6-18 04:00
问题出在这。class Ticket extends Thread implements Runnable
首先这是对线程定义的两种方式，使用一个即 ...

补充：刚刚说的方法是使用Thread方式创建线程
如果用Runnable方式，可修改为

1. class Ticket extends Thread implements Runnable
   
2. {
   
3.           private static int ticket = 100;
   
4.          
   
5.           public void run()
   
6.          {
   
7.                   while(ticket>0)
   
8.                  {
   
9.                             System.out.println(Thread.currentThread().getName()+"--sale--"+ ticket--);
   
10.                  }
    
11.          }
    
12. }
    
13. 
    
14. class ThreadTest1
    
15. {
    
16.            public static void main(String[] args)
    
17.           {
    
18.                    Ticket t_1 = new Ticket();
    
19.                    Ticket t_2 = new Ticket();
    
20.                    Ticket t_3 = new Ticket();
    
21.                    Ticket t_4 = new Ticket();
    
22.                    new Thread(t_1,"one").start();
    
23.                    new Thread(t_2,"two").start();
    
24.                    new Thread(t_3,"three").start();
    
25.                    new Thread(t_4,"four").start();
    
26.           }
    
27. }

复制代码

总之不要两个方法一起用就好。。。对于class Ticket extends Thread implements Runnable位置我没有改，虽然不影响编译，但是最好还是去掉，这样也能明显的看出来用的是Thread方法还是Runnable方法

刘利民 发表于 2013-6-18 07:53
其实最初的目的是为了只想通过Runnable接口，在程序中实现对各个线程的名称的更改，发现用currentThread( ...

1. class Ticket implements Runnable
   
2. {
   
3.            private static int ticket = 100;
   
4.            private String name;
   
5.            Ticket(String name)
   
6.           {
   
7.             this.name= name;
   
8.           }
   
9.           public void run()
   
10.          {
    
11.               
    
12.                           while(ticket>0)
    
13.                          {  
    
14.                                                        
    
15.                                   System.out.println(name+"--sale--"+ ticket--);
    
16.                          }
    
17. 
    
18.          }
    
19. }
    
20. 
    
21. class ThreadTest1
    
22. {
    
23.            public static void main(String[] args)
    
24.           {
    
25.                    Ticket t_1 = new Ticket("one");
    
26.                    Ticket t_2 = new Ticket("two");
    
27.                    Ticket t_3 = new Ticket("three");
    
28.                    Ticket t_4 = new Ticket("four");
    
29.                    new Thread(t_1).start();
    
30.                    new Thread(t_2).start();
    
31.                    new Thread(t_3).start();
    
32.                    new Thread(t_4).start();
    
33.           }
    
34. }

复制代码

你可以这样该下试试，这样就是将Ticket类的对象完全作为创建线程时的参数，并且调用run方法时候，使用的是该参数的名字。