1. import java.util.ArrayList;
   
2. import java.util.Iterator;
   
3. import java.util.List;
   
4. 
   
5. public class ThreadDemo {
   
6. 
   
7.         /**
   
8.          * 7、 编写三各类Ticket、SealWindow、TicketSealCenter分别代表票信息、售票窗口、售票中心。售票中心分配一定数量的票，
   
9.          * 由若干个售票窗口进行出售，利用你所学的线程知识来模拟此售票过程。
   
10.          *
    
11.          */
    
12.         public static void main(String[] args) {
    
13.                 Thread t1 = new Thread(new SealWindow());
    
14.                 t1.setName("1号售票窗口");
    
15.                 Thread t2 = new Thread(new SealWindow());
    
16.                 t2.setName("2号售票窗口");
    
17.                 Thread t3 = new Thread(new SealWindow());
    
18.                 t3.setName("3号售票窗口");
    
19.                 Thread t4 = new Thread(new SealWindow());
    
20.                 t4.setName("4号售票窗口");
    
21.                 Thread t5 = new Thread(new SealWindow());
    
22.                 t5.setName("5号售票窗口");
    
23.                 t1.start();
    
24.                 t2.start();
    
25.                 t3.start();
    
26.                 t4.start();
    
27.                 t5.start();
    
28.         }
    
29. 
    
30. }
    
31. 
    
32. class Ticket {
    
33.         private int id;
    
34. 
    
35.         public int getId() {
    
36.                 return id;
    
37.         }
    
38. 
    
39.         public void setId(int id) {
    
40.                 this.id = id;
    
41.         }
    
42. 
    
43. }
    
44. 
    
45. class SealWindow implements Runnable {
    
46. 
    
47.         @Override
    
48.         public void run() {
    
49.                 sellTicket();
    
50.         }
    
51. 
    
52.         public void sellTicket() {
    
53.                 TicketSealCenter tsc = TicketSealCenter.getInstance();
    
54.                 List<Ticket> tickets = tsc.getTickets();
    
55.                 while (!tickets.isEmpty()) {
    
56.                         Iterator<Ticket> it = tickets.iterator();
    
57.                         Ticket ticket = it.next();
    
58.                         System.out.println(Thread.currentThread().getName() + "...."
    
59.                                         + "卖了一张票，id为" + "..." + ticket.getId());
    
60.                         tickets.remove(ticket);
    
61.                 }
    
62.         }
    
63. }
    
64. 
    
65. // 只有一个售票中心，所以把它设置成单例
    
66. class TicketSealCenter {
    
67.         private static List<Ticket> tickets = new ArrayList<Ticket>();
    
68.         private int ticketNum = 100;
    
69. 
    
70.         private TicketSealCenter() {
    
71.                 // 给每张票设置一个唯一的ID号
    
72.                 setIdToTicket(tickets);
    
73.         }
    
74. 
    
75.         private static TicketSealCenter tsc = new TicketSealCenter();
    
76. 
    
77.         // 提供一个公有方法，获取售票中心对象
    
78.         public static TicketSealCenter getInstance() {
    
79.                 return tsc;
    
80.         }
    
81. 
    
82.         private void setIdToTicket(List<Ticket> tickets2) {
    
83.                 for (int i = 1; i <= ticketNum; i++) {
    
84.                         Ticket ticket = new Ticket();
    
85.                         ticket.setId(i);
    
86.                         tickets.add(ticket);
    
87.                 }
    
88.         }
    
89. 
    
90.         public List<Ticket> getTickets() {
    
91.                 return tickets;
    
92.         }
    
93. 
    
94. }

复制代码

会出现线程卖的是同一张票。求分析并解决。多谢。

大神啊~~~膜拜

针对sellTicket()方法加个线程锁

针对sellTicket()方法加个线程锁

这个答案有帮助

我写了一下，怎么票号是按照从1开始到100，一次递增的啊，不是乱的啊？
while (!tickets.isEmpty()) {
                    synchronized (tickets) {
                            if(tickets.isEmpty()){
                                                        break;
                                                }
                                                Iterator<Ticket> it = tickets.iterator();
                                                Ticket ticket = it.next();
                                               
                                                System.out
                                                                .println(Thread.currentThread().getName()
                                                                                + "...." + "卖了一张票，id为" + "..."
                                                                                + ticket.getId());
                                                tickets.remove(ticket);
                                        }
            }

大神啊。膜拜下

暗影流光 发表于 2014-7-13 16:25
并且在拿到锁之后，还需再次判断集合是否为空，防止线程进入循环后再拿到锁的时候，集合已经为空
...

多谢啊。解决了。:)

并且在拿到锁之后，还需再次判断集合是否为空，防止线程进入循环后再拿到锁的时候，集合已经为空

1. while (!tickets.isEmpty()) {
   
2.                         lock.lock();
   
3.                         //线程拿到锁之后，需要重新判断集合是否为空，防止线程进入循环之后，拿到锁时，集合已经为空
   
4.                         if (tickets.isEmpty()) {
   
5.                                 //如果集合为空，跳出循环时，需要释放锁，防止在循环里面的其它线程，因为拿不到锁而无法结束循环
   
6.                                 lock.unlock();
   
7.                                 break;
   
8.                         }
   
9.                         Iterator<Ticket> it = tickets.iterator();
   
10.                         Ticket ticket = it.next();
    
11.                         System.out.println(Thread.currentThread().getName() + "...."
    
12.                                         + "卖了一张票，id为" + "..." + ticket.getId());
    
13.                         tickets.remove(ticket);
    
14.                         lock.unlock();
    
15.                 }

复制代码

暗影流光 发表于 2014-7-13 16:12
票是共享资源，又有多个线程在操作，所以会出现线程安全问题，你需要在用迭代器取票的时候加锁，将票取完后 ...

加上锁之后还是有问题，程序停在那里了，死循环了貌似。求大神点拨。

票是共享资源，又有多个线程在操作，所以会出现线程安全问题，你需要在用迭代器取票的时候加锁，将票取完后释放锁。