class Ticket extends Thread
{
        private int tick = 100;
        public void run()
        {
            while(true)
            {
                if(tick>0)
                {
                System.out.println(currentThread().getName()+"sale: "+

tick--);
                }
            }
        }



}

class TicketDemo
{
        public static void main(String[] args)
        {
            Ticket t1 = new Ticket();
            Ticket t2 = new Ticket();
              Ticket t3 = new Ticket();
            Ticket t4 = new Ticket();

            t1.start();
            t2.start();
            t3.start();
            t4.start();
        }
}

你创建了四条没有共享数据独立线程，你这个卖票程序很多问题，比如同一数据源，线程安全问题等都没考虑，还出现死循环问题，票卖完了也不会退出循环。
在你的程序框架基础上进行了修改，如下：

1. class Ticket extends Thread
   
2. {
   
3.         private static int tick = 100;        // 保证同一数据源
   
4.         public void run()
   
5.         {
   
6.                 while(true)
   
7.                 {
   
8.                         synchronized(Ticket.class)        // 加同步锁，保证线程安全
   
9.                         {
   
10.                                 if(tick > 0)
    
11.                                 {
    
12.                                         System.out.println(currentThread().getName() + " sale: " + tick--);
    
13.                                 }
    
14.                                 else
    
15.                                 {
    
16.                                         break;                        // 票卖完了，需要退出循环
    
17.                                 }
    
18.                         }
    
19.                         try
    
20.                         {
    
21.                                 Thread.sleep(100);        // 需要稍作休息，否则看不出效果
    
22.                         }
    
23.                         catch (Exception e)
    
24.                         {
    
25.                                 e.printStackTrace();
    
26.                         }
    
27.                 }
    
28.         }
    
29. 
    
30. }
    
31. 
    
32. class TicketDemo
    
33. {
    
34.         public static void main(String[] args)
    
35.         {
    
36.                 Ticket t1 = new Ticket();
    
37.                 Ticket t2 = new Ticket();
    
38.                 Ticket t3 = new Ticket();
    
39.                 Ticket t4 = new Ticket();
    
40. 
    
41.                 t1.start();
    
42.                 t2.start();
    
43.                 t3.start();
    
44.                 t4.start();
    
45.         }
    
46. }

复制代码

因为每个线程start后，都会调用run方法，于是，就会每个线程都卖100张票。
于是就要加入同步代码块：

1. class Ticket implements Runnable
   
2. {
   
3.         private  int tick = 1000;
   
4.         Object obj = new Object();
   
5.         public void run()
   
6.         {
   
7.                 while(true)
   
8.                 {
   
9.                         synchronized(obj)
   
10.                         {
    
11.                                 if(tick>0)
    
12.                                 {
    
13.                                         //try{Thread.sleep(10);}catch(Exception e){}
    
14.                                         System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
    
15.                                 }
    
16.                         }
    
17.                 }
    
18.         }
    
19. }
    
20. 
    
21. 
    
22. class  TicketDemo2
    
23. {
    
24.         public static void main(String[] args)
    
25.         {
    
26. 
    
27.                 Ticket t = new Ticket();
    
28. 
    
29.                 Thread t1 = new Thread(t);
    
30.                 Thread t2 = new Thread(t);
    
31.                 Thread t3 = new Thread(t);
    
32.                 Thread t4 = new Thread(t);
    
33.                 t1.start();
    
34.                 t2.start();
    
35.                 t3.start();
    
36.                 t4.start();
    
37. 
    
38. 
    
39.         }
    
40. }

复制代码