1. class FourTicket
   
2. {
   
3. public static void main(String[] args)
   
4. {
   
5. new TicketSeller ().start();
   
6. new TicketSeller ().start();
   
7. new TicketSeller ().start();
   
8. new TicketSeller ().start();
   
9. 
   
10. }
    
11. }
    
12. 
    
13. class TicketSeller extends Thread
    
14. {
    
15. private static int ticket=100;
    
16. private Object obj=new Object();
    
17. public void run(){
    
18. 
    
19. while (true)
    
20. {
    
21. synchronized(obj)
    
22. {
    
23. if(ticket<=0)
    
24. {break;}
    
25. 
    
26. try
    
27. {
    
28. Thread.sleep(1000);
    
29. }
    
30. catch (Exception e)
    
31. {
    
32. e.printStackTrace();
    
33. }
    
34. 
    
35. System.out.println(getName()+"售出第"+ticket +"张票");
    
36. ticket--;
    
37. }
    
38. }
    
39. }
    
40. }

复制代码

编译没错，可是不能实现同步。请问是哪儿错了？

我复制你的代码测试了一下,问题可能是出在第16行:private Object obj=new Object();
你每次new TicketSeller ().start(); 也就new了一个Object(); 这样你4个线程用的4个Object对象,锁不唯一,所以就不同步了.
改成 private static Object obj=new Object(); 再试试看.
这是我个人看法,坐等高人给出更专业的解释.

锁不结实，换把锁就好了，代码如下：

1. class FourTicket {
   
2.         public static void main(String[] args) {
   
3.                 new TicketSeller().start();
   
4.                 new TicketSeller().start();
   
5.                 new TicketSeller().start();
   
6.                 new TicketSeller().start();
   
7. 
   
8.         }
   
9. }
   
10. 
    
11. class TicketSeller extends Thread {
    
12.         private static int ticket = 100;
    
13.        
    
14. 
    
15.         public void run() {
    
16. 
    
17.                 while (true) {
    
18.                         //用本类作锁即可
    
19.                         synchronized (TicketSeller.class) {
    
20.                                 if (ticket <= 0) {
    
21.                                         break;}
    
22.                                         try {
    
23.                                                 Thread.sleep(1000);
    
24.                                         } catch (Exception e) {
    
25.                                                 e.printStackTrace();
    
26.                                         }
    
27. 
    
28.                                         System.out.println(getName() + "售出第" + ticket + "张票");
    
29.                                         ticket--;                               
    
30.                         }
    
31.                 }
    
32.         }
    
33. }

复制代码

兄弟这个不多解释，实现同时卖票，线程同步就需要卖的是同一个资源：ticket

这时你的视频内容未看到后面的更深的知识点，建议你能弄懂这个练习锁，要表达的意思就是锁的作用，要想实现同步，还需共享资源（后面的视频可以看到）

至于下图出现负数的情况，完全是因为缺少必要的线程锁，出现了线程的等待唤醒机制的时候，不同线程抢夺了cpu 执行权，这些内容后面的视频都有涉及。

到时候你要做的就是，回头再来复习一下，加深理解synchronized 的作用，看看是不是有新的收获

奇怪，还会有重复内容，改了

问题在于你创建线程时,new了四个不同的对象启动线程,自然四个线程的锁不是同一个锁;
可以把锁改成TicketSeller.class,或者用实现Runable接口的方式创建线程

1. class FourTicket
   
2. {
   
3. public static void main(String[] args)
   
4. {
   
5.         TicketSeller t=new TicketSeller();
   
6.         Thread t1=new Thread(t);
   
7.         Thread t2=new Thread(t);
   
8.         Thread t3=new Thread(t);
   
9.         Thread t4=new Thread(t);
   
10.         t1.start();
    
11.         t2.start();
    
12.         t3.start();
    
13.         t4.start();
    
14. }
    
15. }
    
16. 
    
17. class TicketSeller implements Runnable
    
18. {
    
19. private static int ticket=100;
    
20. private Object obj=new Object();
    
21. public void run(){
    
22. 
    
23. while (true)
    
24. {
    
25. synchronized(obj)
    
26. {
    
27. if(ticket<=0)
    
28. {break;}
    
29. 
    
30. try
    
31. {
    
32. Thread.sleep(10);
    
33. }
    
34. catch (Exception e)
    
35. {
    
36. e.printStackTrace();
    
37. }
    
38. 
    
39. System.out.println(Thread.currentThread().getName()+"售出第"+ticket +"张票");
    
40. ticket--;
    
41. }
    
42. }
    
43. }
    
44. }

复制代码

若还有问题，请继续追问；没有的话，请将帖子分类改成【已解决】~