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

复制代码

里面的sleep(10)是线程一进if就睡还是随机睡？如果四个线程都睡了谁去执行Ticket？从运行结果看显然没都睡，如果都睡了就不会出现错票，我想知道的是，这个程序线程是怎么睡的？求帮忙。

进了if就会睡，sleep10毫秒的效果对你来说是不明显的， 你如果该成1000~1秒，只是能看的清楚一点，但线程自己仍是该怎么样还怎么样的

零下五度的水 发表于 2013-11-6 11:44
进了if就会睡，sleep10毫秒的效果对你来说是不明显的， 你如果该成1000~1秒，只是能看的清楚一点，但线程自 ...

好抽象。。。你的意思是4个线程都睡着呗？1秒之后可能2个线程醒了，可能2个线程是阻塞状态呗？是这个意思吗？

你设置的时间太短。系统是按毫秒算的，四个一起睡只有0.01秒。四个轮流睡也只有0.04秒看不出来什么的。
当线程1进入循环睡0.01秒开始执行，主线程读到线程2又进入循环睡0.01秒开始执行。其他两个一样。你这样写的话时间哪怕再长4个线程都会很连贯的运行完成。只不过运行完之后的时间差不一样。把时间改成3000.再看上一次线程4和下一次线程1之间的时间差好了。

前提有一点你要明白，CPU一次只能执行一个线程，所以这4个线程（不包括main)需要抢夺资源，至于谁抢到，就是CPU说的算。
当这4个线程中一个抢到执行权时，sleep(10)只是对这个线程冻结10毫秒,在这10毫秒的时间，这个线程暂时放弃了执行资格，其他3个有执行资格的线程开始继续抢夺执行权。
当这10毫秒时间过去后，之前被sleep(10)的线程恢复了执行资格，但是没有执行权，也就是毕老师视频里画的图中的”阻塞“状态，等待CPU给他分配执行权。

至于你的问题，我的回答是这样的：
1.只要CPU给了一个线程执行权，并且ticket>0，那么这个线程就会执行sleep(10)。
2.sleep(10)不会永久的冻结下去，10毫秒结束，线程又拥有了执行资格。

PS：实现Runnable接口，是每个线程当中都有一个一模一样的run()方法，并不是共用这个run()方法，只有tick是四个线程共用的数据。

你这个sleep方法对程序的结果没什么影响，因为4条线程走的都是同一个方法块，
如果 2条线程走有sleep的方法块，2条线程走没有sleep的方法块，那后两条线程就会在前两条线程sleep的时候多做很多次循环，相当于多出很多次输出语句