编写三各类Ticket、SealWindow、TicketSealCenter分别代表票信息、售票窗口、售票中心。售票中心分配一定数量的票，由若干个售票窗口进行出售，利用你所学的线程知识来模拟此售票过程。 关于这个题，用一个Ticket类做得出来，用三个类咋做不出来了呢？

哥们。。。实在想不出来百度一下，可以搜到的。不过自己不跟着多敲几遍记不住

把你做的代码发一下，大家一起看看怎么解决

我是来学习的

染指青春 发表于 2014-12-19 10:13
哥们。。。实在想不出来百度一下，可以搜到的。不过自己不跟着多敲几遍记不住 ...

呵呵，俺是女汉子滴说！;P

微小山 发表于 2014-12-19 11:23
呵呵，俺是女汉子滴说！

呃呃呃。。。好吧，女汉子不容易啊。加油！！{:3_53:}

这个应该是很简单的吧···

好人一生平安

1. public class Test13 {
   
2.         /**
   
3.          * 编写三各类Ticket、SealWindow、TicketSealCenter分别代表票信息、售票窗口、售票中心。售票中心分配一定数量的票，
   
4.          * 由若干个售票窗口进行出售，利用你所学的线程知识来模拟此售票过程。
   
5.          *
   
6.          * 多个售票窗口一起工作，这是一个多线程考题
   
7.          */
   
8. 
   
9.         public static void main(String[] args) {
   
10.                 // 新建一个售票中心
    
11.                 TicketSealCenter center = new TicketSealCenter();
    
12.                 // 设置好车票出发和目的地，这时候票信息中还没有座位号
    
13.                 center.setTicket("广州", "南宁");
    
14.                 // 分配票的数量
    
15.                 center.setAmount(1000);
    
16. 
    
17.                 // 创建一个售票中心 实现Runnable 在run方法中会给加上座位号 然后打印
    
18.                 SealWindow seal = new SealWindow(center.getTicket(), center.getAmount());
    
19.                 // 创建线程并执行
    
20.                 Thread t1 = new Thread(seal, "一号窗");
    
21.                 Thread t2 = new Thread(seal, "二号窗");
    
22.                 Thread t3 = new Thread(seal, "三号窗");
    
23.                 t1.start();
    
24.                 t2.start();
    
25.                 t3.start();
    
26. 
    
27.         }
    
28. 
    
29. }
    
30. 
    
31. class Ticket {
    
32.         // 票的属性有座位号跟出发目的地
    
33.         private int num;
    
34.         private String off;
    
35.         private String des;
    
36. 
    
37.         // 有参构造（参数中不含座位号） 以便让售票中心初始化
    
38.         public Ticket(String off, String des) {
    
39.                 this.off = off;
    
40.                 this.des = des;
    
41.         }
    
42. 
    
43.         // 设置座位号让售票窗口打印设置好的票
    
44.         public void setNum(int num) {
    
45.                 this.num = num;
    
46.         }
    
47. 
    
48.         // 票信息
    
49.         public String toString() {
    
50.                 return off + "------>"  + des + "\r\n" + "座位号" + num;
    
51.         }
    
52. 
    
53. }
    
54. 
    
55. class SealWindow implements Runnable {
    
56.         private int amount;
    
57.         private Ticket ticket;
    
58. 
    
59.         // 有参构造 传入的是要卖的票的信息 还有 一共可以卖多少张票
    
60.         public SealWindow(Ticket ticket, int amount) {
    
61.                 this.ticket = ticket;
    
62.                 this.amount = amount;
    
63.         }
    
64. 
    
65.         public void run() {
    
66.                 while (true) {
    
67.                         synchronized (this) {
    
68.                                 if (amount > 0) {
    
69.                                         try {
    
70.                                                 Thread.sleep(2);
    
71.                                         } catch (InterruptedException e) {
    
72.                                         }
    
73.                                         // 这里就是设置票的座位号 设置好 打印
    
74.                                         ticket.setNum(amount--);
    
75.                                         System.out
    
76.                                                         .println(Thread.currentThread().getName() + "售出：");
    
77.                                         System.out.println(ticket.toString());
    
78.                                         System.out.println();
    
79.                                 } else {
    
80.                                         System.out.println("无票可售");
    
81.                                         break;
    
82.                                 }
    
83.                         }
    
84.                 }
    
85.         }
    
86. }
    
87. 
    
88. // 售票中心
    
89. class TicketSealCenter {
    
90.         private int amount;
    
91.         private Ticket ticke;
    
92.         //设置总票数
    
93.         public void setAmount(int amount) {
    
94.                 this.amount = amount;
    
95.         }
    
96. 
    
97.         // 分配可以售出的总票数
    
98.         public int getAmount() {
    
99.                 return amount;
    
100.         }
     
101.         //设置票信息的出发地和目的地（不含座位号）
     
102.         public void setTicket(String off, String des) {
     
103.                 ticke = new Ticket(off, des);
     
104.         }
     
105. 
     
106.         //返回票信息（还不含座位号）
     
107.         public Ticket getTicket() {
     
108.                 return ticke;
     
109.         }
     
110. }

复制代码

这是我写的，希望可以参考一下，不知道这样算不算对得上题意

微小山 发表于 2014-12-19 11:23
呵呵，俺是女汉子滴说！

:(:(啊啊啊啊

早上不知道是不是回的这个帖子，当时理解错误，重新敲了一遍，就是老毕的多线程消费者与生产者，这里操作资源当做票的集合就行了。下面是我的代码，我在售票的时候加了休眠，不然每次都是同一个线程把售票中心生产的票给卖完了

1. public class Test4 {
   
2. 
   
3.         public static void main(String[] args) {
   
4. 
   
5.                 Ticket ticket = new Ticket("芜湖", 0);
   
6.                 TicketSealCenter tsc1 = new TicketSealCenter(ticket);
   
7.                 SealWindow sw1 = new SealWindow(ticket);
   
8.                 SealWindow sw2 = new SealWindow(ticket);
   
9.                 SealWindow sw3 = new SealWindow(ticket);
   
10.                 // SealWindow sw4 = new SealWindow(ticket);
    
11. 
    
12.                 Thread th1 = new Thread(tsc1);
    
13.                 th1.setName("售票中心");
    
14.                 Thread th2 = new Thread(sw2);
    
15.                 th2.setName("售票窗口1");
    
16.                 Thread th3 = new Thread(sw1);
    
17.                 th3.setName("售票窗口2");
    
18.                 Thread th4 = new Thread(sw3);
    
19.                 th4.setName("售票窗口3");
    
20. 
    
21.                 th1.start();
    
22.                 th2.start();
    
23.                 th3.start();
    
24.                 th4.start();
    
25.         }
    
26. 
    
27. }
    
28. 
    
29. class SealWindow implements Runnable {
    
30. 
    
31.         private Ticket ticket;
    
32. 
    
33.         public SealWindow(Ticket ticket) {
    
34.                 this.ticket = ticket;
    
35.         }
    
36. 
    
37.         @Override
    
38.         public void run() {
    
39. 
    
40.                 while (true) {
    
41.                         ticket.seal();
    
42.                        
    
43.                         try {
    
44.                                 Thread.sleep(500);
    
45.                         } catch (InterruptedException e) {
    
46.                                 // TODO Auto-generated catch block
    
47.                                 e.printStackTrace();
    
48.                         }
    
49.                 }
    
50.         }
    
51. }
    
52. 
    
53. class TicketSealCenter implements Runnable {
    
54. 
    
55.         private Ticket t;
    
56. 
    
57.         public TicketSealCenter(Ticket t) {
    
58.                 this.t = t;
    
59.         }
    
60. 
    
61.         @Override
    
62.         public void run() {
    
63. 
    
64.                 while (true) {
    
65.                         // 生产芜湖车次的车票
    
66.                         t.pro("芜湖");
    
67.                 }
    
68.         }
    
69. 
    
70. }
    
71. 
    
72. class Ticket {
    
73. 
    
74.         static LinkedList<Ticket> pool = new LinkedList<Ticket>();
    
75. 
    
76.         private String destination;
    
77.         private int site = 0;
    
78. 
    
79.         public Ticket(String destination, int site) {
    
80.                 this.destination = destination;
    
81.                 this.site = site;
    
82.         }
    
83. 
    
84.         private boolean flag = false;
    
85. 
    
86.         private Lock lock = new ReentrantLock();
    
87.         private Condition con_pro = lock.newCondition();
    
88.         private Condition con_seal = lock.newCondition();
    
89. 
    
90.         public void pro(String des) {
    
91.                 lock.lock();
    
92.                 try {
    
93.                         while (flag) {
    
94.                                 con_pro.await();
    
95.                         }
    
96.                         //每次生产若干票
    
97.                         int num = (int) (Math.random() * 10)+1;
    
98.                         for (int i = 0; i < num; i++) {
    
99.                                 Ticket t = new Ticket(des, site++);
    
100.                                 pool.addFirst(t);
     
101.                                 System.out.println(Thread.currentThread().getName() + "生产了"
     
102.                                                 + t.toString());
     
103.                         }
     
104. 
     
105.                         flag = true;
     
106.                         con_seal.signal();
     
107. 
     
108.                 } catch (InterruptedException e) {
     
109.                         e.printStackTrace();
     
110.                 } finally {
     
111.                         lock.unlock();
     
112.                 }
     
113. 
     
114.         }
     
115. 
     
116.         /**
     
117.          * 这个方法被若干线程操作
     
118.          */
     
119.         public void seal() {
     
120. 
     
121.                 lock.lock();
     
122.                 try {
     
123.                         while (!flag) {
     
124.                                 con_seal.await();
     
125.                         }
     
126.                        
     
127.                         if (pool.size() > 0) {
     
128.                                 // 如果有票，售票窗口就开始卖票并打印信息
     
129.                                 System.out.println(Thread.currentThread().getName() + "售出了"
     
130.                                                 + pool.removeLast().toString());
     
131.                         } else {
     
132.                                 // 如果没有有票，唤醒售票中心线程生产票
     
133.                                 flag = false;
     
134.                                 con_pro.signal();
     
135.                         }
     
136.                 } catch (InterruptedException e) {
     
137.                         e.printStackTrace();
     
138.                 }finally{
     
139.                         lock.unlock();
     
140.                 }
     
141.         }
     
142. 
     
143.         @Override
     
144.         public String toString() {
     
145.                 // destination车次第site座
     
146.                 return destination + "车次第" + site + "座";
     
147.         }
     
148. 
     
149. }

复制代码

后悔药 发表于 2014-12-19 15:20
早上不知道是不是回的这个帖子，当时理解错误，重新敲了一遍，就是老毕的多线程消费者与生产者，这里操作资 ...

嗯，看了一下打的蛮好的，女汉给你点32个赞。呵呵，在seal的地方是不是那个if可以改为while，让它把发布的票都拿走掉

微小山 发表于 2014-12-19 16:10
嗯，看了一下打的蛮好的，女汉给你点32个赞。呵呵，在seal的地方是不是那个if可以改为while，让它把发布 ...

你把那个500ms的休眠注解掉就可以了。程序运行的时候seal方法的外层已经有while循环了，我自己测试就是每次都是同一个线程刚解锁就又进入循环抢到锁，导致其他线程一直拿不到执行权，所以同一个线程把票抢完了，加了一个500ms休眠才解决。

:(:(给你们的代码点赞:lol