A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

如果发现BUG了就说下哈  呵呵
  1. package cn.itcast.bank;

  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import java.util.Random;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.TimeUnit;

  7. public class MainClass {
  8.         public static void main(String[] args) {
  9.                 int windowNumber;// 窗口编号
  10.                 /* 创建4个普通窗口 */
  11.                 for (windowNumber = 1; windowNumber <= 4; windowNumber++) {
  12.                         new ServiceWindow(CustomerType.GENERAL, windowNumber);
  13.                 }
  14.                 new ServiceWindow(CustomerType.FAST, windowNumber++);// 创建1个快速窗口
  15.                 new ServiceWindow(CustomerType.VIP, windowNumber++);// 创建1个VIP窗口
  16.                 NumberMachine.getInstance().open();// 打开号码管理器的开关
  17.         }
  18. }

  19. /* 服务窗口类 */
  20. class ServiceWindow {
  21.         private static NumberMachine numberMachine = NumberMachine.getInstance();// 所有服务窗口共享一个号码管理器
  22.         private CustomerType type;// 窗口类型
  23.         private int number;// 窗口编号

  24.         /**
  25.          * @param type
  26.          *            窗口类型
  27.          * @param number
  28.          *            窗口编号
  29.          */
  30.         public ServiceWindow(CustomerType type, int number) {
  31.                 this.number = number;
  32.                 this.type = type;
  33.                 Executors.newScheduledThreadPool(1).schedule(new Runnable() {
  34.                         @Override
  35.                         public void run() {
  36.                                 Random random = new Random();
  37.                                 do {
  38.                                         /* 向号码管理器索取下一个顾客,如果没有索取到则返回null */
  39.                                         Customer customer = numberMachine.getCustomer(ServiceWindow.this);
  40.                                         if (null == customer) {
  41.                                                 System.out.println(ServiceWindow.this.getNumber()
  42.                                                                 + "号窗口空闭中");
  43.                                                 try {
  44.                                                         Thread.sleep(2000);// 窗口休息2秒再进行下一次索取
  45.                                                 } catch (InterruptedException e) {
  46.                                                         e.printStackTrace();
  47.                                                 }
  48.                                         } else {
  49.                                                 System.out.println(customer.toString() + "到"
  50.                                                                 + ServiceWindow.this.getNumber() + "号窗口办理业务");
  51.                                                 try {
  52.                                                         Thread.sleep((random.nextInt(19000) + 1000));// 如果索取到了顾客,随机生成为该顾客服务的时间
  53.                                                 } catch (InterruptedException e) {
  54.                                                         e.printStackTrace();
  55.                                                 }
  56.                                                 System.out.println(ServiceWindow.this.getNumber()
  57.                                                                 + "号窗口为" + customer.toString() + "办理完毕");
  58.                                         }
  59.                                 } while (true);
  60.                         }

  61.                 }, 0, TimeUnit.SECONDS);
  62.         }

  63.         public int getNumber() {
  64.                 return number;// 返回窗口的的编号
  65.         }

  66.         public CustomerType getType() {
  67.                 return type;// 返回窗口的类型
  68.         }
  69. }

  70. /* 号码管理器类 */
  71. class NumberMachine {
  72.         private int customers = 0;// 客户编号,每来一个顾客,这个编号的值就会增加1
  73.         private List<Customer> generalList = new ArrayList<Customer>();// 普通用户队列
  74.         private List<Customer> fastList = new ArrayList<Customer>();// 快速用户队列
  75.         private List<Customer> VIPList = new ArrayList<Customer>();// VIP用户队列
  76.         private static NumberMachine numberMachine = new NumberMachine();// 单例
  77.         private boolean onOff = false;// 号码管理器的开关初始状态为关

  78.         private NumberMachine() {
  79.         }

  80.         public static NumberMachine getInstance() {
  81.                 return numberMachine;
  82.         }

  83.         public void open() {// 打开开关,让号码管理器开始工作
  84.                 onOff = true;
  85.                 Executors.newScheduledThreadPool(1).schedule(new Runnable() {
  86.                         @Override
  87.                         public void run() {
  88.                                 Random random = new Random();
  89.                                 while (onOff) {
  90.                                         try {
  91.                                                 Thread.sleep((random.nextInt(3) + 1) * 1000);// 随机生成顾客到来的时间间隔
  92.                                         } catch (InterruptedException e) {
  93.                                                 e.printStackTrace();
  94.                                         }
  95.                                         switch (random.nextInt(10)) {// VIP客户:快速客户:普通客户=1:3:6
  96.                                         case 0:
  97.                                                 /* VIP客户加入到VIP用户队列 */
  98.                                                 VIPList.add(new Customer(CustomerType.VIP, ++customers));
  99.                                                 System.out.println(VIPList.get(VIPList.size() - 1)
  100.                                                                 .toString() + "进入VIP用户队列");
  101.                                                 break;
  102.                                         case 1:
  103.                                         case 2:
  104.                                         case 3:
  105.                                                 /* 快速用户加入到快速用户队列 */
  106.                                                 fastList.add(new Customer(CustomerType.FAST,
  107.                                                                 ++customers));
  108.                                                 System.out.println(fastList.get(fastList.size() - 1)
  109.                                                                 .toString() + "进入快速用户队列");
  110.                                                 break;
  111.                                         default:
  112.                                                 /* 普通用户加入到普通用户队列 */
  113.                                                 generalList.add(new Customer(CustomerType.GENERAL,
  114.                                                                 ++customers));
  115.                                                 System.out.println(generalList.get(
  116.                                                                 generalList.size() - 1).toString()
  117.                                                                 + "进入普通用户队列");
  118.                                         }
  119.                                 }
  120.                         }
  121.                 }, 0, TimeUnit.SECONDS);

  122.         }

  123.         /* 多个线程都在向号码管理器索取客户,所以要同步,如果不同步可能会出现两个窗口取到同一个客户 */
  124.         public synchronized Customer getCustomer(ServiceWindow serviceWindow) {
  125.                 Customer customer = null;// 取到的客户,初始值为null
  126.                 switch (serviceWindow.getType()) {
  127.                 case GENERAL:// 普通窗口在索取
  128.                         if (0 < generalList.size()) {
  129.                                 customer = generalList.get(0);
  130.                                 generalList.remove(0);
  131.                         } else if (0 < VIPList.size()) {
  132.                                 customer = VIPList.get(0);
  133.                                 VIPList.remove(0);
  134.                         } else if (0 < fastList.size()) {
  135.                                 customer = fastList.get(0);
  136.                                 fastList.remove(0);
  137.                         }
  138.                         break;
  139.                 case FAST:// 快速窗口在索取
  140.                         if (0 < fastList.size()) {
  141.                                 customer = fastList.get(0);
  142.                                 fastList.remove(0);
  143.                         } else if (0 < VIPList.size()) {
  144.                                 customer = VIPList.get(0);
  145.                                 VIPList.remove(0);
  146.                         } else if (0 < generalList.size()) {
  147.                                 customer = generalList.get(0);
  148.                                 generalList.remove(0);
  149.                         }
  150.                         break;
  151.                 case VIP:// VIP窗口在索取
  152.                         if (0 < VIPList.size()) {
  153.                                 customer = VIPList.get(0);
  154.                                 VIPList.remove(0);
  155.                         } else if (0 < generalList.size()) {
  156.                                 customer = generalList.get(0);
  157.                                 generalList.remove(0);
  158.                         } else if (0 < fastList.size()) {
  159.                                 customer = fastList.get(0);
  160.                                 fastList.remove(0);
  161.                         }
  162.                 }
  163.                 return customer;// 返回取到的客户
  164.         }

  165.         public void close() {// 关闭号码管理器
  166.                 onOff = false;
  167.         }
  168. }

  169. class Customer {
  170.         private CustomerType type;// 客户类型
  171.         private int number;// 客户编号

  172.         public Customer(CustomerType type, int number) {
  173.                 this.type = type;
  174.                 this.number = number;
  175.         }

  176.         public String toString() {
  177.                 switch (type) {
  178.                 case GENERAL:
  179.                         return "第" + number + "号普通用户";
  180.                 case FAST:
  181.                         return "第" + number + "号快速用户";
  182.                 case VIP:
  183.                         return "第" + number + "号VIP用户";
  184.                 }
  185.                 return null;
  186.         }

  187.         public CustomerType getType() {
  188.                 return type;
  189.         }

  190.         public void setType(CustomerType type) {
  191.                 this.type = type;
  192.         }

  193.         public int getNumber() {
  194.                 return number;
  195.         }

  196.         public void setNumber(int number) {
  197.                 this.number = number;
  198.         }
  199. }

  200. /* 3种不同的服务类型 */
  201. enum CustomerType {
  202.         GENERAL, FAST, VIP
  203. };
复制代码

评分

参与人数 1技术分 +2 收起 理由
admin + 2 赞一个!

查看全部评分

1 个回复

倒序浏览
牛人   学习了       还没看到

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马