1. class Ticket implements Runnable
   
2. {
   
3.        private int tick=100;
   
4.        Object obj=new Object();
   
5.        public void run()
   
6.        {
   
7.            while(true)  //为什不直接写while(tick >0）然后while(tick>0)放在synchronized 同步锁里执行，这样不就少了一步判断了吗？
   
8.            {
   
9.                 synchronized(obj)
   
10.                {
    
11.                      if (tick>0)
    
12.                             System.out.println(Thread.currentThread().getName()+tick--);
    
13.                }
    
14.            }
    
15.       }
    
16. }
    
17. 
    
18. class TicketSeal
    
19. {
    
20.            public static void main(String[] args)
    
21.             {
    
22.                  Ticket t=new Ticket();
    
23.                   Thread t1=new Thread(t);
    
24.                   Thread t2=new Thread(t);
    
25.                   Thread t3=new Thread(t);
    
26.                   Thread t4=new Thread(t);
    
27.                   t1.start();
    
28.                   t2.start();
    
29.                   t3.start();
    
30.                   t4.start();
    
31.              }
    
32. }
    
33. 
    

复制代码

执行结果：程序没有自动结束（按照视频里的写法）



如果我这样写：

1. class Ticket implements Runnable //extends Thread
   
2. {
   
3.       private int tick=100;
   
4.       Object obj=new Object();
   
5.       public void run()
   
6.      {
   
7.            synchronized(obj)
   
8.           {
   
9.                   while (tick>0)   //把之前这里的if（tick>0）改成while(tick>0)
   
10.                   {
    
11.                         System.out.println(Thread.currentThread().getName()+"..."+tick--);
    
12.                    }
    
13.            }
    
14.       }
    
15. }
    

复制代码

程序执行结果：程序刚好能执行完100次，并自动跳出。


如果我这样加，是不是同步锁就没有意义了，自始至终都是一个线程在循环，只有第一个线程循环结束后，第二个线程才有机会进来？




   
                       

while(true)  //相当每个买票人来询问锁，如果没人买，就进去买一张
           {
                synchronized(obj)
               {
                     if (tick>0)
                            System.out.println(Thread.currentThread().getName()+tick--);
               }
           }

而你改后：
synchronized(obj)
          {
                  while (tick>0)   //相当一个人进去后，把所有票都买了
                  {
                        System.out.println(Thread.currentThread().getName()+"..."+tick--);
                   }
           }

亲~~  你够狠~~
# synchronized(VIP)VIP提供单间服务，VIP不出来，别人就不能进来
#           {
#                   while (tick>0)   //单间服务不是白提供的，进来了就多买点票吧~~~~买多少呢？？？买完！不然你就别想出去~~
#                   {
#                         System.out.println(Thread.currentThread().getName()+"..."+tick--);
#                    }
#            }

你说为什么没有自动结束，那是因为那是一个while循环，而且一直是true的，所以自动结束不了。
第二个问题楼上的都已回答的很好了。