黑马程序员_银行业务调度

-------android培训、java培训、期待与您交流！ ----------

银行业务调度系统

模拟实现银行业务调度系统逻辑，具体需求如下：

1.      银行内有6个业务窗口，1-4号窗口为普通窗口。5号窗口为快速窗口，6号窗口为vip窗口

2.      有三种对应类型的客户，vip客户，普通客户，快速客户。

3.      异步随机生成各种类型的客户，生成各种类型用户的概率比例为：

a)        Vip客户：普通客户：快速客户 = 1：6：3

4.      客户办理业务所需时间有最大值和最小值，在该范围内随机设定给每个vip客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值（办理业务的过程可通过线程sleep的方式模拟。）

5.      各类型客户在起对应窗口按顺序依次办理业务。

6.      当vip窗口和快速业务窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。

7.      随机生成客户时间间隔以及办理时间的最大值和最小值自定，可以设置。

8.      不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

 

 

面向对象的分析和设计：

有三种对应类型的客户：VIP客户，普通客户，快速客户，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务。

1.      首先应该有一个号码管理器对象，让这个对象不断的产生号码就等于随机生成了客户。

2.      由于有三类客户，每类客户的号码编排都是完全独立的。所以本系统一共要产生三个号码管理器对象。各自管理一类用户的排队号码。这三个号码管理器对象统一由一个号码机器管理。这个号码机器在整个系统中始终只能有一个他要被设计成单例。

各类型客户在起对应窗口按顺序依次办理业务，准确的说，应该是窗口一次叫号。

1.      服务窗口每次找号码管理器获取当前要被服务的号码。

 

图例说明：

 

NumberManager类和NumberMachine类

         NumberManager类

1.      定义一个用于存储上一个客户号码的成员变量和用于存储所有等待服务的客户号码的队列集合。

2.      定义一个产生新号码的方法和获取马上要为之服务的号码的方法，这两个方法被不同的线程操作了相同的数据，所以要进行同步。

NumberMachine类

         定义三个成员变量分别指向三个NumberManager对象，分别表示普通，快速和vip客户的号码管理器。定义三个对应的方法来返回这三个NumberManager对象。将NumberMachine设计成单例。

CustomerType类

系统中有三种类型的客户，所以要定义一个枚举类，其中定义三个成员分别表示三种不同类型的客户。重写toString方法,使用switch语句分别根据当前客户类型返回中文类型的名称。顺带复习了switch语句有关枚举的使用。这个枚举在switch中的使用居然让我忘了。得反省一下。

ServiceWindow类

定义start方法，使用jdk1.5的新的线程技术启动一个线程，根据客户类型分别调用不同的服务方法（customService，expressService，vipService）为随机产生的客户服务。这些服务方法中详细打印客户的等待，服务中和服务完成以及各阶段服务的耗时信息。以便检查运行结果。

MainClass类：客户端调用

分别创建四个客户端窗口，一个快速窗口和一个vip窗口对象。并调用这些对象的start方法启动线程。再创建三个定时器分别去创建新的不同类型的客户的号码。

 

实现代码：

         packagecom.isoftstone.interview.bankqueue;

 

import java.util.ArrayList;

import java.util.List;

 

public class NumberManager{

   private int lastNumber = 1;

   private List<Integer> queueNumber = new ArrayList<>();

  

   public synchronizedIntegergenerateNewManager() {

      queueNumber.add(lastNumber);

      return lastNumber++;

   }

  

   public synchronizedInteger fetchServiceNumber() {

      Integer number = null;

      if (queueNumber.size()> 0) {

         number = queueNumber.remove(0);

      }

      return number;

   }

}

 

packagecom.isoftstone.interview.bankqueue;

 

public class NumberMachine{

   private static NumberMachine instance = new NumberMachine();

  

   private NumberManager commonManager = newNumberManager();

   private NumberManager expressManager = newNumberManager();

   private NumberManager vipManager = newNumberManager();

  

   public NumberManager getCommonManager() {

      return commonManager;

   }

   public NumberManager getExpressManager() {

      return expressManager;

   }

   public NumberManager getVipManager() {

      return vipManager;

   }

   private NumberMachine(){

     

   }

  

   public static NumberMachine getInstance(){

      return instance;

   }

  

}

 

packagecom.isoftstone.interview.bankqueue;

 

import java.util.Random;

importjava.util.concurrent.Executors;

 

public class ServiceWindow{

  

   private CustomerTypetype = CustomerType.COMMON;

   private int windowId = 1;

  

   public voidsetType(CustomerType type) {

      this.type = type;

   }

  

   public voidsetWindowId(int windowId) {

      this.windowId =windowId;

   }

  

   private voidcommonService() {

      String windowName = "第" + windowId + "号" + type + "窗口";

      Integer number = NumberMachine.getInstance().getCommonManager().fetchServiceNumber();

      System.out.println(windowName + "正在获取任务");

      if (number != null){

         System.out.println(windowName + "为第" + number + "个普通客户服务");

         long beginTime = System.currentTimeMillis();

         int maxServeTime = Constants.MAX_SERVICAE_TIME- Constants.MIN_SERVICE_TIME;

         long serveTime = newRandom().nextInt(maxServeTime) +1 + Constants.MIN_SERVICE_TIME;

         try {

            Thread.sleep(serveTime);

         }

         catch (InterruptedExceptione) {

            e.printStackTrace();

         }

         long costTime = System.currentTimeMillis();

         System.out.println(windowName + "为第" + number + "个普通客户完成服务，耗时" + ((costTime -beginTime) / 1000) + "秒");

      }

      else {

         System.out.println(windowName + "没有取到服务任务");

         try {

            Thread.sleep(1000);

         }

         catch (InterruptedExceptione) {

            e.printStackTrace();

         }

      }

   }

  

   private voidexpressService() {

      String windowName = "第" + windowId + "号" + type + "窗口";

      Integer number = NumberMachine.getInstance().getExpressManager().fetchServiceNumber();

      System.out.println(windowName + "正在获取任务");

      if (number != null){

         System.out.println(windowName + "为第" + number + "个" + type + "客户服务");

         long beginTime = System.currentTimeMillis();

         try {

            Thread.sleep(Constants.MIN_SERVICE_TIME);

         }

         catch (InterruptedExceptione) {

            e.printStackTrace();

         }

         long costTime = System.currentTimeMillis();

         System.out.println(windowName + "为第" + number + "个" + type + "客户完成服务，耗时" + ((costTime - beginTime) / 1000) + "秒");

      }

      else {

         System.out.println(windowName + "没有取到服务任务");

         commonService();

      }

   }

  

   private voidvipService() {

      String windowName = "第" + windowId + "号" + type + "窗口";

      Integer number = NumberMachine.getInstance().getVipManager().fetchServiceNumber();

      System.out.println(windowName + "正在获取任务");

      if (number != null){

         System.out.println(windowName + "为第" + number + "个" + type + "客户服务");

         long beginTime = System.currentTimeMillis();

         try {

            Thread.sleep(Constants.MAX_SERVICAE_TIME);

         }

         catch (InterruptedExceptione) {

            e.printStackTrace();

         }

         long costTime = System.currentTimeMillis();

         System.out.println(windowName + "为第" + number + "个" + type + "客户完成服务，耗时" + ((costTime - beginTime) / 1000) + "秒");

      }

      else {

         System.out.println(windowName + "没有取到服务任务");

         commonService();

      }

   }

  

   public void start(){

      Executors.newSingleThreadExecutor().execute(new Runnable() {

         @Override

         public void run() {

            while (true) {

                switch (type) {

                   case COMMON:

                      commonService();

                      break;

                   case EXPRESS:

                      expressService();

                      break;

                   case VIP:

                      vipService();

                      break;

                   default:

                      break;

                }

            }

         }       

      });

   }

}

 

packagecom.isoftstone.interview.bankqueue;

 

public enum CustomerType {

   COMMON, EXPRESS, VIP;

  

   public StringtoString() {

      switch (this) {

         case COMMON:

            return "普通";

         case EXPRESS:

            return "快速";

         case VIP:

            return name();

         default:

            break;

      }

      return null;

   }

}

 

packagecom.isoftstone.interview.bankqueue;

 

public class Constants {

   public static int MAX_SERVICAE_TIME =10000;

   public static int MIN_SERVICE_TIME = 1000;

   public static int COMMON_CUSTOMER_INTERVAL_TIME= 1;

}

 

packagecom.isoftstone.interview.bankqueue;

 

importjava.util.concurrent.Executors;

importjava.util.concurrent.TimeUnit;

 

public class MainClass {

   public static void main(String[] ars) {

      for (int i = 1; i< 5; i++) {

         ServiceWindow commonWindow = new ServiceWindow();

         commonWindow.setWindowId(i);

         commonWindow.start();

      }

      ServiceWindow vipWindow = newServiceWindow();

      vipWindow.setType(CustomerType.VIP);

      vipWindow.start();

     

      ServiceWindow exptessWindow = new ServiceWindow();

      exptessWindow.setType(CustomerType.EXPRESS);

      exptessWindow.start();

     

      Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {

         @Override

         public void run() {

            Integer number = NumberMachine.getInstance().getCommonManager().generateNewManager();

            System.out.println("第" + number + "号普通客户等待服务");

         }

      }, 0, Constants.COMMON_CUSTOMER_INTERVAL_TIME, TimeUnit.SECONDS);

     

      Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {

         @Override

         public void run() {

            Integer number = NumberMachine.getInstance().getExpressManager().generateNewManager();

            System.out.println("第" + number + "号快速客户等待服务");

         }

      }, 0, Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6, TimeUnit.SECONDS);

     

      Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {

         @Override

         public void run() {

            Integer number = NumberMachine.getInstance().getVipManager().generateNewManager();

            System.out.println("第" + number + "号vip客户等待服务");

         }

      }, 0, Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2, TimeUnit.SECONDS);

   }

}

 

-------android培训、java培训、期待与您交流！ ----------

详细请查看：http://edu.csdn.net/heima/