编写三各类Ticket、SealWindow、TicketSealCenter分别代表票信息、售票窗口、售票中心。
        售票中心分配一定数量的票，由若干个售票窗口进行出售，利用你所学的线程知识来模拟此售票过程。
* @author Administrator
*
*/
public class TreadDemo {
        public static void main(String[] args) {
                Ticket t= new Ticket(100);
                SealWindow ss = new SealWindow(t);
                Thread t1 = new Thread(ss);
                Thread t2 = new Thread(ss);
                Thread t3 = new Thread(ss);
                t1.start();
                t2.start();
                t3.start();
        }
       
}
class Ticket {
       
        private int num;
        private boolean flag= false;
       
        public Ticket(int num) {
                super();
                this.num = num;
        }

        public synchronized void output(){
                while (!flag) {
                        if(num>0){
                                System.out.println(Thread.currentThread().getName()+"-----------"+num--);
                        }else{
                                flag = true;
                        }
                }               
        }
}
//售票窗口
class SealWindow implements Runnable{
        private Ticket ticket;

        public SealWindow(Ticket ticket) {
                super();
                this.ticket = ticket;
        }

        @Override
        public void run() {
                while (true) {
                        ticket.output();
                        try {
                                Thread.sleep(100);
                        } catch (InterruptedException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                        }          
                }
        }
}
提问：我的程序线程没有切换，如何改变

你这样不是只创建一个售票窗口而已吗？题目不是要求开四个售票窗口吗？

我觉得实际卖票的是售票中心提供的功能
而每个窗口的卖票是调用的是售票中心提供的功能
所以将每个窗口的对象传递给售票中心，表明此窗口在卖票。

lwj123 发表于 2015-2-23 12:29
你这样不是只创建一个售票窗口而已吗？题目不是要求开四个售票窗口吗？

我觉得实际卖票的是售票中心提供的 ...

看的毕老师视频，类似于生产者、消费者的，票有卖的方法和产生票的方法，售票窗口调用卖的方法，售票中心有产生票的方法。。。我的问题是只有一个线程起作用，即使我产生三个窗口，但不会切换，请教咋解决啊

我帮你修改了一下，我运行了下，我估计是你的while循环有问题，你发现没有你的事循环中再调用循环
修改代码：
import java.util.*;
public class TreadDemo {
     public static void main(String[] args) {
         Ticket t= new Ticket(1000);
         SealWindow s1 = new SealWindow(t);
         //SealWindow s2 = new SealWindow(t);
         //SealWindow s3 = new SealWindow(t);
         Thread t1 = new Thread(s1);
         Thread t2 = new Thread(s1);
         Thread t3 = new Thread(s1);
         t1.start();
         t2.start();
         t3.start();
     }
         
}
class Ticket
{
         
     private int num;
     private boolean flag= false;
     
     public Ticket(int num) {
             super();
             this.num = num;
     }

     public synchronized void output()
     {
         if(num>0)
         {
           System.out.println(Thread.currentThread().getName()+"-----------"+num--);
           try{Thread.sleep(50);}catch(InterruptedException e){}
           
         }            
     }
}
//售票窗口
class SealWindow implements Runnable
{
                 private Ticket ticket;
               
                 public SealWindow(Ticket ticket) {
                     super();
                     this.ticket = ticket;
                 }
               
                 @Override
                 public void run()
                 {
                     while(true)
                     {
                                ticket.output();
                     }
                 }
}

1. <div class="blockcode"><blockquote><div class="blockcode"><blockquote>package cn.itheima.demo;
   
2. 
   
3. /**
   
4. * 这是售票窗口
   
5. *
   
6. * @author pinger
   
7. *
   
8. */
   
9. public class SealWindow {
   
10.         public static void main(String[] args) {
    
11.                 // 创建共享资源
    
12.                 Ticket t = new Ticket();
    
13. 
    
14.                 TicketSealCenter gt = new TicketSealCenter(t);
    
15. 
    
16.                 // 设置线程
    
17.                 Thread t1 = new Thread(gt, "窗口一");
    
18.                 Thread t2 = new Thread(gt, "窗口二");
    
19.                 Thread t3 = new Thread(gt, "窗口三");
    
20.                 // 线程启动
    
21.                 t1.start();
    
22.                 t2.start();
    
23.                 t3.start();
    
24.         }
    
25. }
    

复制代码

package cn.itheima.demo;

/**
* 这是售票中心
*
* @author pinger
*
*/
public class TicketSealCenter implements Runnable {
        // 设置构造，共享资源对象
        private Ticket t;

        public TicketSealCenter(Ticket t) {
                this.t = t;
        }

        @Override
        public void run() {

                while (true) {

                        synchronized (t) {
                                try {
                                        Thread.sleep(100);
                                } catch (InterruptedException e) {
                                        e.printStackTrace();
                                }
                                // 消费资源
                                Ticket.sellTicket();
                        }

                }
        }

}

package cn.itheima.demo;

/**
* 这是一个票的基本信息的类
*
* @author pinger
*
*/
public class Ticket {
        // 票信息
        private static int tickets = 100;

        // 售票的方式
        public static void sellTicket() {

                if (tickets > 0) {
                        // 进行消费
                        System.out.println(Thread.currentThread().getName() + "正在售"
                                        + Ticket.tickets-- + "张票");

                }
        }
}

liaohongjie 发表于 2015-2-23 16:17
我帮你修改了一下，我运行了下，我估计是你的while循环有问题，你发现没有你的事循环中再调用循环
修改代码 ...

谢了 学习了

万合天宜 发表于 2015-2-23 16:36
package cn.itheima.demo;

/**

恩恩 谢了

锁的位置锁在了循环外面 也就是说一个线程进去后把门锁上然后自己狂循环做完了全部工作才把门打开,其它线程进来后发现活已经干完了,也就从始至终没干过活.

liaohongjie 发表于 2015-2-23 16:17
我帮你修改了一下，我运行了下，我估计是你的while循环有问题，你发现没有你的事循环中再调用循环
修改代码 ...

你这个好像不对。

我的做法，同步方法放在售票中心类中。

1. package com.itheima;
   
2. 
   
3. /**
   
4. *第6题：编写三个类Ticket、SealWindow、TicketSealCenter分别代表票信息、售票窗口、售票中心。
   
5. * 售票中心分配一定数量的票，由若干个售票窗口进行出售，利用你所学的线程知识来模拟此售票过程。
   
6. * @author zl
   
7. *思路：多个线程访问同一个数据存储单元，需要同步。
   
8. *详细：
   
9. *一，定义票。每产生一个新票，其序号就自动增1，需要静态sid；类的成员变量为id（记录每个票的当前id）。
   
10. *二，定义窗口。新增窗口自动产生id，故需要静态sid；需要指定其拿票的中心；重写run方法，有票就拿。
    
11. *三，定义中心。中心必须有装票的容器或数组；指定当前可取的票；同步被拿走票和产生票的方法。
    
12. */
    
13. public class Test06_Synchronized {
    
14. 
    
15.         public static void main(String[] args) {
    
16.                 // 定义TicketSealCenter和SealWindow实例
    
17.                 TicketSealCenter tsc = new TicketSealCenter();
    
18.                 tsc.put(30);
    
19.                 SealWindow sw1 = new SealWindow(tsc);
    
20.                 SealWindow sw2 = new SealWindow(tsc);
    
21.                 SealWindow sw3 = new SealWindow(tsc);
    
22.                
    
23.                 //定义多个线程
    
24.                 new Thread(sw1).start();
    
25.                 new Thread(sw2).start();
    
26.                 new Thread(sw3).start();
    
27.         }
    
28. }
    
29. /*
    
30. * 定义Ticket类；
    
31. * 属性包括：Ticket的id
    
32. * 需要构造方法；
    
33. * 需要id的set和get方法
    
34. */
    
35. class Ticket {
    
36.         //Ticket的序号
    
37.         private int id;
    
38.         //定义一个静态变量，记录下一个新产生的票的序号
    
39.         private static int sid = 1;       
    
40.        
    
41.         //构造方法
    
42.         Ticket() {
    
43.                 this.setId(sid);
    
44.                 sid ++;
    
45.         }
    
46.        
    
47.         //定义set和get方法
    
48.         public int getId() {
    
49.                 return id;
    
50.         }
    
51.         public void setId(int id) {
    
52.                 this.id = id;
    
53.         }
    
54. }
    
55. 
    
56. /*
    
57. * 定义SealWindow类，实现Runnable以开启新的线程
    
58. * 属性：SealWindow的id，与之联系的TicketSealCenter对象
    
59. * 构造方法：每增加一个SealWindow，id加1；参数包括特定的TicketSealCenter对象
    
60. * 重写run方法
    
61. */
    
62. class SealWindow implements Runnable {
    
63.         //定义SealWindow的id号
    
64.         private int id;
    
65.         //定义静态变量，自动记录下一个新产生的的SealWindow序号
    
66.         private static int sid = 1;
    
67.         //定义对应的TicketSealCenter，即该SealWindow向哪个TicketSealCenter拿票
    
68.         private TicketSealCenter tsc;
    
69. 
    
70.         //构造方法
    
71.         SealWindow(TicketSealCenter tsc) {
    
72.                 this.setId(sid);
    
73.                 //每新创建一个SealWindow实例，就自动记录下一个新产生的的SealWindow序号，方便
    
74.                 sid ++;
    
75.                 this.tsc = tsc;
    
76.         }
    
77. 
    
78.         //重写run方法
    
79.         public void run() {
    
80.                 // 若TicketSealCenter有票，该窗口就每隔一段时间拿一张Ticket
    
81.                 while(tsc.getIndex()>0) {
    
82.                         tsc.pop(this.id);
    
83.                         try {
    
84.                                 Thread.sleep((int)(Math.random()*200));
    
85.                         } catch (InterruptedException e) {
    
86.                                 e.printStackTrace();
    
87.                         }
    
88.                 }       
    
89.         }
    
90. 
    
91.         //定义set和get方法
    
92.         public int getId() {
    
93.                 return id;
    
94.         }
    
95.         public void setId(int id) {
    
96.                 this.id = id;
    
97.         }
    
98. }
    
99. 
    
100. /*
     
101. * 定义TicketSealCenter类
     
102. * 属性：Ticket数组，以及当前空票的指针
     
103. * 构造方法：初始化Ticket容器的方法
     
104. * 拿和产生Ticket的方法需要同步
     
105. */
     
106. class TicketSealCenter {
     
107.         //定义Ticket数组和下一张空票的指针
     
108.         Ticket[] ts = new Ticket[100];
     
109.         int index = 0;
     
110. 
     
111.         //定义拿票的方法，需要同步
     
112.         synchronized public Ticket pop(int sealWindowId) {
     
113.                 // 执行一次，先判断是否拿完，若有票则index--，否则返回null
     
114.                 if(index>0) {
     
115.                         //拿出票后，index指针往前移动一个单元
     
116.                         index --;
     
117.                         //获取拿出的票的信息
     
118.                         Ticket t = ts[index];
     
119.                         //打印拿票的信息，打印信息需要在此处打印为好；若在SealWindow类中的run方法里打印，则会导致拿票和打印信息两动作不同步
     
120.                         System.out.println( "窗口" + sealWindowId + "：拿出" + t.getId() + "号票");
     
121.                         return t;
     
122.                 }
     
123.                 //没有票就返回空
     
124.                 return null;       
     
125.         }
     
126. 
     
127.         //定义产生票的方法，需要同步
     
128.         synchronized public void put(int tikNum) {
     
129.                 if(index==0) {
     
130.                         for(int i=0; i<tikNum; i++) {
     
131.                                 this.ts[i] = new Ticket();
     
132.                                 index ++;
     
133.                         }
     
134.                 }
     
135.         }
     
136. 
     
137.         //定义get和set方法
     
138.         public int getIndex() {
     
139.                 return index;
     
140.         }
     
141.         public void setIndex(int index) {
     
142.                 this.index = index;
     
143.         }
     
144. }

复制代码