1. package com.heima.thread;
   
2. 
   
3. public class ThreadSafe {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.             //4)创建Tikets实例
   
10.                 Tikets tk = new Tikets();
    
11.                 //3） 创建线程实例
    
12.                 Thread t1 = new Thread(tk,"线程1");
    
13.                 Thread t2 = new Thread(tk,"线程2");
    
14.                 Thread t3 = new Thread(tk,"线程3");
    
15.                  
    
16.                 //5）启动线程
    
17.                 t1.start();
    
18.                 t2.start();
    
19.                 t3.start();
    
20.         }
    
21. 
    
22. }
    
23. //1）定义一个类并且实现Runnable接口
    
24. class Tikets implements Runnable
    
25. {
    
26. int tiketsNum = 100;
    
27. //2）复写run方法        
    
28. @Override
    
29.         public void run() {
    
30.                  while(tiketsNum>0){
    
31.                                 System.out.println(Thread.currentThread().getName()+"卖出"+tiketsNum--);
    
32.                 }
    
33.          }
    
34.         
    
35. }

复制代码

帮我分析（结果）一下出现两个100的情况：
线程2卖出100
线程1卖出100
线程1卖出98
线程1卖出97
线程2卖出99
线程1卖出95
线程3卖出96
线程1卖出93
线程2卖出94
线程1卖出91
线程3卖出92

难道是System.out.println(Thread.currentThread().getName()+"卖出"+tiketsNum--);只是打印了而没有进行自减操作？

当打印 线程2 的时候，还没自减，然后线程1 获得运行权，。

因为tiketsNum--是后置的自减运算，后置时是先使用后计算；并且在线程代码中没有加同步锁。
根据结果看，有可能是线程2执行时，获取到了tiketsNum的值100，但还没有执行自减的操作，此时线程1获取到了执行权，也打印出了tiketsNum=100。
如下例：

1. public class Test01 {
   
2.     /**
   
3.      * @param args
   
4.      */
   
5.     public static void main(String[] args) {
   
6.         //4)创建Tikets实例
   
7.             Tikets tk = new Tikets();
   
8.             //3） 创建线程实例
   
9.             Thread t1 = new Thread(tk,"线程1");
   
10.             Thread t2 = new Thread(tk,"线程2");
    
11.             Thread t3 = new Thread(tk,"线程3");
    
12.             
    
13.             //5）启动线程
    
14.             t1.start();
    
15.             t2.start();
    
16.             t3.start();
    
17.     }
    
18. 
    
19. }
    
20. //1）定义一个类并且实现Runnable接口
    
21. class Tikets implements Runnable
    
22. {
    
23. int tiketsNum = 100;
    
24. //2）复写run方法        
    
25.     public void run() {
    
26.              while(tiketsNum>0){
    
27.                  try {
    
28.                                         System.out.println(Thread.currentThread().getName()+"卖出"+tiketsNum);
    
29.                                         Thread.sleep(1);//线程1执行到此处时，线程2获取到执行权，tiketsNum并没有自减。
    
30.                                         tiketsNum--;
    
31.                                 } catch (InterruptedException e) {
    
32.                                         e.printStackTrace();
    
33.                                 }
    
34.             }
    
35.      }
    
36. }

复制代码

运行结果：
线程1卖出100
线程2卖出100
线程3卖出100
线程1卖出99
线程3卖出97
线程2卖出98

尹桥印 发表于 2013-6-13 11:53
没加锁。把视频往后多看看就明白是怎么回事了。

没加锁我知道，毕老师分析的是出现0和-1的情况，但是现在这个是出现了两个100

桉树 发表于 2013-6-13 11:58
当打印 线程2 的时候，还没自减，然后线程1 获得运行权，。

我也是这么想的，就是不确定  谢了

funneies 发表于 2013-6-13 14:55
因为tiketsNum--是后置的自减运算，后置时是先使用后计算；并且在线程代码中没有加同步锁。
根据结果看，有 ...

恩恩 ，谢谢了

问题已经解决的，请及时更改分类为已解决，方便大家查阅，没有的继续追问
关于提问技巧请看：http://bbs.itheima.com/thread-53229-1-1.html

楼主你好  如果帖子的问题已解决，请把帖子的类型改为已解决，如果没解决请继续追问。

袁梦希 发表于 2013-6-14 18:08
楼主你好  如果帖子的问题已解决，请把帖子的类型改为已解决，如果没解决请继续追问。 ...

我不会改啊  ，能不能教教我啊

知行 发表于 2013-6-14 22:40
我不会改啊  ，能不能教教我啊

点击自己帖子下面有个编辑   然后有个帖子的类型  上面有下拉菜单  有个已解决