1. class Ticket implements Runnable
   
2. {
   
3.         private int tick=100;
   
4.         Object obj=new Object();
   
5.         public  void run()
   
6.         {
   
7.                 while(true)
   
8.                 {
   
9.                         synchronized(obj)
   
10.                         {
    
11.                                 if(tick>0)
    
12.                                 {
    
13.                                         try        
    
14.                                         {
    
15.                                                 Thread.sleep(10);
    
16.                                         }
    
17.                                         catch(Exception e)
    
18.                                         {
    
19.                                         }
    
20.                                         System.out.println(Thread.currentThread().getName()+".."+tick--);
    
21.                                 }
    
22.                         }
    
23.                 }
    
24.         }
    
25. }
    
26. class  TicketDemo
    
27. {
    
28.         public static void main(String[] args)
    
29.         {
    
30.                 Ticket t=new Ticket();
    
31.                 //t.run();
    
32.                 Thread t1=new Thread(t);
    
33.                 Thread t2=new Thread(t);
    
34.                 Thread t3=new Thread(t);
    
35.                 Thread t4=new Thread(t);
    
36.                 t1.start();
    
37.                 t2.start();
    
38.                 t3.start();
    
39.                 t4.start();
    
40. 
    
41.         
    
42.         }
    
43. }
    

复制代码

代码和老师的一模一样，可运行的结果怎么都是一个线程的名字，老师的有多个线程名e:\线程

只能说明你的电脑秒杀了这个程序，其他线程虽然启动了，但是抢不到权限。或者是很短时间内Thred--0就把这个程序执行完了。建议把100改成1000试试。

你的代码是正确的。出现总是一个线程名称的现象是因为CUP分配给线程的执行权的问题，这个和计算机本身有关系。

两个线程抢占同一cpu资源，谁抢到了谁用，简单的说就好比两人抢同一工具，谁抢到了谁用,对于cpu来就给谁用这是随机的

如果运行结果是正常的话，就是CPU 分配的问题了，CPU的核心数量也有关系。
你可以试着这样， 把同步锁的粒度再次缩小，
private Integer tick=100 ;   //  把tick定义成一个 Integer 型  也就是 int  的包装类  注意：这是一个对象，不是一个类型了
用同步锁去锁 tick (对象) 的时候，  每次只能有一个线程去执行 ，这样的思路是不是好一点呢？

当然 Thread.sleep(100);  时间长一点 可以更好的去观察

郑世光 发表于 2012-11-16 13:13
程序正确，运行正常，你自己再试试吧。
部分结果：
Thread-0..100

我运行过，结果没什么变化，只要当我把sleep时间延长，才会有多个线程名，这会不会是因为电脑Cpu的问题？

程序正确，运行正常，你自己再试试吧。
部分结果：
Thread-0..100
Thread-0..99
Thread-0..98
Thread-0..97
Thread-3..96
Thread-3..95
Thread-2..94
Thread-2..93
Thread-2..92
Thread-2..91
Thread-1..90
Thread-1..89
Thread-1..88
Thread-1..87
Thread-1..86
Thread-1..85
Thread-1..84
Thread-2..83
Thread-2..82
Thread-2..81
Thread-2..80