在写代码的时候，很自以为是的就想偷懒
就写了对象的简写格式
然后运行结果就出错了
请大家帮我看看
谢谢

1. public class TicketDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 Ticket t = new Ticket();//创建票的对象
   
6. 
   
7.                 Thread t1 = new Thread(t);//创建线程，并把Runnable接口的子类对象传递给Thread的子类对象
   
8.                 Thread t2 = new Thread(t);
   
9.                 Thread t3 = new Thread(t);
   
10.                 t1.start();//开启线程
    
11.                 t2.start();
    
12.                 t3.start();
    
13.         }
    
14. }
    
15. class Ticket implements Runnable//实现Runnable接口
    
16. {
    
17.         private int num = 100;
    
18.         <font color="red">//Object obj = new Object();//这里如果是这样写的话，程序运行时不会生成错票</font>
    
19.         public void  run()//复写run方法，把需要被多线程执行的代码写入run方法中
    
20.         {
    
21.                 while(true)
    
22.                 {
    
23.                         <font color="red">synchronized(new Object())//这里把对象简写的话，就打印错票了，</font>
    
24. {
    
25.                                 if(num>0)
    
26.                                 {
    
27.                                         try{Thread.sleep(10);}
    
28.                                         catch(Exception e){}
    
29.                                         System.out.println(Thread.currentThread().getName()+"...ticket sale..."+num--);
    
30. }
    
31.                         }
    
32.                 }
    
33.         }
    
34. }

复制代码

我都试了一下，为什么不能用简写的格式创建对象。难道那个对象被垃圾回收了？？？？？？？？？？？？？？

1. package cm.nti56;
   
2. public class TicketDemo
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 Ticket t = new Ticket();//创建票的对象
   
7. 
   
8. /*              Thread t1 = new Thread(t);//创建线程，并把Runnable接口的子类对象传递给Thread的子类对象
   
9.                 Thread t2 = new Thread(t);
   
10.                 Thread t3 = new Thread(t);
    
11.                 t1.start();//开启线程
    
12.                 t2.start();
    
13.                 t3.start();*/
    
14.                //开启线程
    
15.                 new Thread(t).start();
    
16.                 new Thread(t).start();
    
17.                 new Thread(t).start();
    
18.         }
    
19. }
    
20. class Ticket implements Runnable//实现Runnable接口
    
21. {
    
22.         private int num = 100;
    
23.         //创建同步锁，要在while循环前创建不然会创建很多不同的实例对象,那样就是多个锁了。
    
24.        Object obj = new Object();
    
25.         public void  run()//复写run方法，把需要被多线程执行的代码写入run方法中
    
26.         {
    
27.                 while(true)
    
28.                 {
    
29.                     synchronized(obj)
    
30. {
    
31.                                 if(num>0)
    
32.                                 {
    
33.                                         try{Thread.sleep(10);}
    
34.                                         catch(Exception e){}
    
35.                                         System.out.println(Thread.currentThread().getName()+"...ticket sale..."+num--);
    
36. }                        }
    
37.                 }
    
38.         }
    
39. }

复制代码

每次都生成了新”锁“吧，所有线程应该用同一个锁。

你直接用synchronized(new Object());这样的话，每个线程进来都会重新创建一个新的对象，违背了锁的对象必须是同一个的原则，当然会出错了。

如果你要是在synchronized中new对象的话是不是你们每次判断锁的时候都会生成一个对象，那么就会生成多个锁，只要判断就会生成一个锁，而同步的时候是能有一个锁