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

复制代码

结果是：Thread0 都执行完，其他线程没有执行

会说话的木头 发表于 2014-4-14 16:33
还真是，仁兄看到什么地方了？报名哪一期？

也在看多线程能。相报33期呢，不知道能不能赶上。。

askyle 发表于 2014-4-14 16:23
引用毕老师的话：
因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行。
明确一点，在某一个时刻，只 ...

仁兄引经据典，佩服！
仁兄看到什么地方了？报的哪一期？

optimisticpig 发表于 2014-4-14 16:21
代码没有问题，你多运行几次应该就有其他的了

还真是，仁兄看到什么地方了？报名哪一期？

引用毕老师的话：
因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行。
明确一点，在某一个时刻，只能有一个程序在运行，（多核除外）
cpu 在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象多线程的运行行为在互相抢夺cpu的执行权。
  
  这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多次，cpu说的算。

代码没有问题，你多运行几次应该就有其他的了