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{Thread.sleep(10);}catch(Exception e){}
    
14.                                         System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
    
15.                                 }
    
16.                         }
    
17.                 }
    
18.         }
    
19. }
    
20. 
    
21. 
    
22. class  TicketDemo2
    
23. {
    
24.         public static void main(String[] args)
    
25.         {
    
26. 
    
27.                 Ticket t = new Ticket();
    
28. 
    
29.                 Thread t1 = new Thread(t);
    
30.                 Thread t2 = new Thread(t);
    
31.                 Thread t3 = new Thread(t);
    
32.                 Thread t4 = new Thread(t);
    
33.                 t1.start();
    
34.                 t2.start();
    
35.                 t3.start();
    
36.                 t4.start();
    
37. 
    
38. 
    
39.         }
    
40. }
    

复制代码

疑惑：毕老师讲解的synchronized锁是当Thread-0线程进入synchronized标识的代码中时，程序就上锁了，然后执行锁住的代码中内容，
其他的Thread就进不来了，当Thread-0执行完，他释放锁，别的线程才能进来，于是他举个例子，火车上厕所，几个人排队，等先进去的哥们出来，
其他哥们才能进去，那么这里的意思就是：第一个哥们方便完出来，其他三个哥们抢着进去，但是实际你不能上完了开门出来还跟其他哥们抢接着上啊，
代码运行时候，一个线程连续抢着执行了好多次，如图
Thread-3....sale : 98
Thread-3....sale : 97
Thread-3....sale : 96
Thread-3....sale : 95
那么这里可以理解为，哥们方便完觉得又得上，于是和其他3个哥们开始抢？
这里的意思是，无论哪个线程先执行，在锁外边的，所有线程(包括在厕所里的)都有公平的执行权(而不是方便完的就不能抢了)，这么理解对吗？

太经典了。

高境 发表于 2013-1-10 15:14
其实我们现在的电脑都是多核CPU，所以，会出现类似的情况的~~

哦哦，学到了哦~~

舒远 发表于 2013-1-10 15:10
你这么理解是对的 。出来的线程和其他等待的线程同样具备执行权。谁抢到谁上呗。好比那个上厕所的哥们，人 ...

这个比喻太贴切了，知道是那么回事，就是没法说服自己相信，被你一说，完全理解了{:3_67:}

其实我们现在的电脑都是多核CPU，所以，会出现类似的情况的~~

你这么理解是对的 。出来的线程和其他等待的线程同样具备执行权。谁抢到谁上呗。好比那个上厕所的哥们，人家拉肚子了，他不是还得接着抢么？不是说他执行完出来了就失去执行权了。。