1. /*
   
2. 多个窗口同时卖票
   
3. */
   
4. class MaiPiao implements Runnable
   
5. {
   
6.         private static int num=1;//每个对象中不该重复同样的票，静态就全局了
   
7.         public void run()
   
8.         {
   
9.                 synchronized(new Object())
   
10.                 {
    
11.                         for (;num<=50 ;num++)
    
12.                         {
    
13.                                 System.out.println(Thread.currentThread().getName()+"卖出-"+num+"-号票");
    
14.                         }
    
15.                 }
    
16.         }
    
17. }
    
18. class Testmp2
    
19. {
    
20.         public static void main(String[] args)
    
21.         {
    
22.                 MaiPiao d=new MaiPiao();
    
23.                 Thread x1=new Thread(d,"窗口A");
    
24.                 Thread x2=new Thread(d,"窗口B");
    
25.                 Thread x3=new Thread(d,"窗口C");
    
26.                 x1.start();
    
27.                 x2.start();
    
28.                 x3.start();
    
29.         }
    
30. }

复制代码

本该打印50个不同的票号，但是打印结果里总是有某两张票重复打印，一共52行，

而且重复的一般是靠前的票号，像1和2，见图中红圈的地方。
我觉得这不是synchronized能解决的，谁知道是什么原因啊？？？

我来解释解释。
核心问题在于锁与static属性，
static声明的属性表示为全局属性或类属性，性质上属于类，在你的程序中也就属于MaiPiao类，
使用同步时需要获得对象监视器的锁，问题就出在这里了，static num属性属于MaiPiao类，不属于Object，你的同步锁用Object就不合适了，
用MaiPiao.class或this给同步上锁，这才比较合适。
修改代码如下：

1. import java.io.*;
   
2. import java.util.*;
   
3. 
   
4. /*
   
5. 多个窗口同时卖票
   
6. */
   
7. class MaiPiao implements Runnable
   
8. {
   
9.         private static int num=1;//每个对象中不该重复同样的票，静态就全局了
   
10.         public void run()
    
11.         {
    
12.                 synchronized(this)//MaiPiao.class也可以
    
13.                 {
    
14.                         for (;num<=50 ;num++)
    
15.                         {
    
16.                                 System.out.println(Thread.currentThread().getName()+"卖出-"+num+"-号票");
    
17.                         }
    
18.                 }
    
19.         }
    
20. }
    
21. public class J
    
22. {
    
23.         public static void main(String[] args)
    
24.         {
    
25.                 MaiPiao d=new MaiPiao();
    
26.                 Thread x1=new Thread(d,"窗口A");
    
27.                 Thread x2=new Thread(d,"窗口B");
    
28.                 Thread x3=new Thread(d,"窗口C");
    
29.                 x1.start();
    
30.                 x2.start();
    
31.                 x3.start();
    
32.         }
    
33. }

复制代码

我有点迷糊关于那个静态 num了
在我看来：
很显然 你用的并不是共享的同一个int num;
你创建了3个线程  new了三个买票对象 应该有三个Num静态对象把。
回头我试验以下 new 3个变量名称和类型都一样的变量，看看是三个变量还是只有一个共享变量。
这里我认为 num不是共享的。


因为如果num是共享的 另一个线程不会开始就是1的


其次，  1

最重要的一点，
你的同步锁 使用的不是一个锁，
三个线程是不同步的
你的锁是

new Object 你想想 三个线程 三个 new Object 那不是有了三个锁了吗？
如上所说 锁可以用 MaiPiao.class  这样用的就是一个锁了。。



再者 也是很重要的一点
从输出就可以出来。
你的同步锁起来的代码不对
按照你的代码
如果你的锁按照上面所说设置正确
那么 一个买票窗口不卖到50张票 第二个窗口是不可能卖票的
因为你同步把   for 循环圈里面了。
一个线程进入了锁 那么 就会执行for循环  他for循环不执行完  他不会解锁 别的线程别想运行。

可是因为你锁设置的不对 所以才会出现 第一个窗口才卖了 9张票 第二个窗口就卖了。

所以 关于第一个静态num  我实在是模糊了  我觉得你的静态num 肯定有3个  我建议你把 静态num定义在主函数所在的类中   然后通过 类名.变量名 调用

关于锁对象  我可以肯定你用错了。

还有锁起来的代码，应该这样：


              
               
                        for (;num<=50 ;num++)
                        {
                                 synchronized(this)//MaiPiao.class也可以
                                 {
                                             System.out.println(Thread.currentThread().getName()+"卖出-"+num+"-号票");
                                 }
                        }
               

mvplee 发表于 2013-6-12 01:03
我来解释解释。
核心问题在于锁与static属性，
static声明的属性表示为全局属性或类属性，性质上属于类，在 ...

不正确、

1. package thread;
   
2. 
   
3. class MyTicketss implements Runnable
   
4. {
   
5.         private int num = 50;//50张票
   
6.         @Override
   
7.         public void run() {
   
8.                         for (int i = 0; i < 100; i++) {//卖100次。多少次其实不影响！
   
9.                                 synchronized(this){
   
10.                                 if(num>0){
    
11.                                         try {
    
12.                                                 Thread.sleep(1);//模拟延迟，导致意外的发生
    
13.                                         } catch (InterruptedException e) {
    
14.                                                 e.printStackTrace();
    
15.                                         }        System.out.println(Thread.currentThread().getName()+"卖出了第"+num--+"张票");
    
16.                                 }
    
17.                 }}
    
18.         }
    
19. }
    
20. 
    
21. public class TicketAlter {
    
22.         public static void main(String[] args) throws InterruptedException {
    
23.                 MyTicketss m = new MyTicketss();
    
24.                 new Thread(m,"A").start();
    
25.                 new Thread(m,"B").start();
    
26.                 new Thread(m,"C").start();
    
27.         }
    
28. }

复制代码

没看出哪里错，除了this那点，上面两位修改的都不完全正确！
向别人展示（工作中）的代码要保证正确，就是自己确认无误的，见过的惯用法！！加油黑马人！！

mvplee 发表于 2013-6-12 01:03
我来解释解释。
核心问题在于锁与static属性，
static声明的属性表示为全局属性或类属性，性质上属于类，在 ...

你这只有A窗口在运行

尹桥印 发表于 2013-6-12 09:32
一句话：你的锁不是一个锁。
怎么能每次都new Object()，你要先new出来，用的时候把Object这个对象传入 ...

这个回答才是最正确的

Super_Class 发表于 2013-6-12 10:49
这个回答才是最正确的

可是我改成synchronized(this)或者synchronized(已经new好的b对象)问题就更费解了，出现的情况是全程只有一个线程跑，这样就输出了指定的张数，不会多出几张了。
而且无论总张数多大，都是只有一个线程在跑。
我已经一团糟了

锁的问题我改了两种，并把总票数改成1000便于观察，现象是这样：
synchronized的参数写new Object()时，运行结果有1002行，就是说某两张票是重复的，并且经多次试验，重复的票号都是靠前的数字。无论设定张数改多少，输出总是比它多两行。
像这样：
窗口A卖出: 1 号票
窗口A卖出: 2 号票
窗口A卖出: 3 号票
窗口A卖出: 4 号票  重复票
窗口B卖出: 4 号票  重复票
窗口B卖出: 6 号票  重复票
窗口B卖出: 7 号票
窗口A卖出: 5 号票
窗口B卖出: 8 号票
窗口C卖出: 6 号票  重复票
窗口B卖出: 10 号票
窗口A卖出: 9 号票
窗口B卖出: 12 号票
窗口C卖出: 11 号票
..........

而像老师视频那样synchronized的参数里写前面new好的b时，就只有A一个线程运行，输出1000行，程序结束。其实可能不是锁的问题。。。。是while的问题吗？？？
老师写是run是这样：  （而且这里synchronized的参数写new Object()也没有问题。）

1. public void run()
   
2. {
   
3.         while(true)
   
4.         {
   
5.                 synchronized(b)
   
6.                 {
   
7.                         if(num<=1000)
   
8.                         {
   
9.                                 System.out.println(Thread.currentThread().getName()+"卖出:"+(num++)+" 号票");
   
10.                         }
    
11.                 }
    
12.         }
    
13. }

复制代码

楼主：
1、很汗颜，咋一看，没错啊，接着调试,又想特性，N次后才明白为什么。
2、先说正确的代码吧，经过我调试的。

1. 
   
2. <P>/*
   
3. 多个窗口同时卖票
   
4. */
   
5. class MaiPiao implements Runnable
   
6. {
   
7.         private static int num=1;//每个对象中不该重复同样的票，静态就全局了
   
8.   public void run()
   
9.         {
   
10.                
    
11.                for (;num<=50 ;num++)//num++不是线程对其的操作，因此不用放到锁里；同时这里的num<=50是第一重判断
    
12.                {
    
13.                        synchronized(MaiPiao.class)  //用MaiPiao.class   就保证了x1  x2  x3用的是同一个锁
    
14.                       { </P>
    
15. <P>                              if(num<=50)//这里是第二重判断，原因：假设x1拿到锁，此时num=50，正常执行；同时锁外，x2 或x3也拿到了num=50，等待进锁；</P>
    
16. <P>                                                //没有if判断的话，等x1释放完锁，x2直接进锁而不会去for那里判断，然后执行锁里内容，打印51</P>
    
17. <P>                                                //同理，x3进锁打印52。有了if就能杜绝这种情况。
    
18.                               {
    
19.                                      System.out.println(Thread.currentThread().getName()+"卖出-"+num+"-号票");//线程对共享数据num的操作就这一句，因此锁住
    
20.                               }
    
21.                        }
    
22.                 }
    
23.                  
    
24.         }
    
25. }
    
26. class Testmp2
    
27. {
    
28.         public static void main(String[] args)
    
29.         {
    
30.                 MaiPiao d=new MaiPiao();
    
31.                 Thread x1=new Thread(d,"窗口A");
    
32.                 Thread x2=new Thread(d,"窗口B");
    
33.                 Thread x3=new Thread(d,"窗口C");
    
34.                 x1.start();
    
35.                 x2.start();
    
36.                 x3.start();
    
37.         }
    
38. } </P>

复制代码

3、需要了解的几个关键点：
      synchronized(对象）：在这里有两层含义，一是加锁，线程拿到锁后，不执行完里面代码块，不会释放锁，同时其他线程谁也别想进来；二是  对象，注意，如果就一个线程，那么该对象是谁无所谓，如果是多个线程操作一个共享数据的话，那么这里就要注意了，多个线程用的synchronized  对象必须是是同一个，一定注意是唯一的，必须是同一个。再注意，多次new的对象，不是同一个对象。
      synchronized(对象)：锁里面的内容要选择好，一定是线程对数据的操作，如果不是，就不要放进来。
      额外话：当一个类进内存会产生  类.class对象   ，是唯一的，视频里老师有讲。所以我一般用这个。
4、对于楼主代码的解析：

1. 
   
2. <OL>
   
3. <LI>private static int num=1;//每个对象中不该重复同样的票，静态就全局了
   
4. </LI>
   
5. <LI>        public void run()
   
6. 
   
7. <LI>        {
   
8. 
   
9. <LI>                synchronized(new Object())//三个线程每执行一次就new一个新对象，锁不唯一
   
10. 
    
11. <LI>                {
    
12. 
    
13. <LI>                        for (;num<=50 ;num++)//线程没有操作该语句，不能放到锁里。同时，线程在执行完锁内所有代码后才释放锁。
    
14. 
    
15. <LI>                        {
    
16. 
    
17. <LI>                                System.out.println(Thread.currentThread().getName()+"卖出-"+num+"-号票");
    
18. 
    
19. <LI>                        }
    
20. 
    
21. <LI>                }
    
22. 
    
23. <LI>        }
    
24. </LI></OL>
    
25. <P> </P>

复制代码

5、我认为这样已经比较详细了，楼主可明白了？

孔雀东南飞 发表于 2013-6-12 15:26
楼主：
1、很汗颜，咋一看，没错啊，接着调试,又想特性，N次后才明白为什么。
2、先说正确的代码吧，经过我 ...

很详细！！我也拿你的试了几遍，"num++不是线程对其的操作"这个解释我再琢磨会

孔雀东南飞 发表于 2013-6-12 15:26
楼主：
1、很汗颜，咋一看，没错啊，接着调试,又想特性，N次后才明白为什么。
2、先说正确的代码吧，经过我 ...

1. public void run()
   
2. {               
   
3.            for (;num<=50 ;num++)
   
4.            {
   
5.                    try{Thread.sleep(20);}catch(Exception e){}//<span style="background-color: rgb(255, 255, 255);">手动睡眠</span>
   
6.                    synchronized(MaiPiao.class)  
   
7.                   {
   
8.                           if(num<=50)
   
9.                           {
   
10.                                 System.out.println(Thread.currentThread().getName()+"卖出-"+num+"-号票");
    
11.                           }
    
12.                   }
    
13.                   try{Thread.sleep(20);}catch(Exception e){}//<span style="background-color: rgb(255, 255, 255);">手动睡眠</span>
    
14.         }                 
    
15. }

复制代码

我折腾了下，又发现问题，在for里锁的前后手动睡眠，时间设大点，这样一般都是两个线程睡那儿等第三个打印，输出是下面的规律
窗口A卖出-1-号票
窗口C卖出-1-号票
窗口B卖出-1-号票
窗口A卖出-4-号票
窗口C卖出-4-号票
窗口B卖出-4-号票
窗口A卖出-7-号票
窗口C卖出-7-号票
窗口B卖出-7-号票
窗口A卖出-10-号票
窗口C卖出-10-号票
窗口B卖出-10-号票
......

抱歉，之前虽然运行结果对了，但仔细再看看，还真有问题。
问题在于，对于num的值，只能在某一时刻只能由一个线程来访问。在我上边的代码里，把num放到锁外是错误的，如果放到锁外，会出现重复值的情况，尤其是sleep较长时间后。我又想了下，把控制循环的局部变量单独提出来，另外把num放到锁里面，这样就可以了。

1.         public void run()
   
2.         {               
   
3.                    for (int x=1;x<=50 ;x++)
   
4.                    {
   
5.                            try
   
6.                         {
   
7.                                 //Thread.sleep(20);//手动睡眠
   
8.                         }catch(Exception e)
   
9.                         {
   
10.                         }
    
11. 
    
12.                            synchronized(MaiPiao.class)  
    
13.                           {
    
14.                                   if(num<=50)
    
15.                                   {
    
16.                                                 System.out.println(Thread.currentThread().getName()+"卖出-"+num+"-号票");
    
17.                                   }
    
18.                                 num++;
    
19.                           }
    
20. 
    
21.                            try
    
22.                         {
    
23.                                 //Thread.sleep(20);//手动睡眠
    
24.                         }catch(Exception e)
    
25.                         {
    
26.                         }
    
27.                 }                 
    
28.         }

复制代码