黑马程序员---银行业务调度系统

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

示意图：

NumberManager类：用于产生号码和获取服务号码，所以定义了产生号码和获取服务号码的方法：generateNumber(),fetchServiceNumber().因为这两个方法操作的都是ArrayList集合中的数据并且这两个方法是由不同的线程来执行的，所以两个方法都需要加上同步．

 

NumberMachine类：这个类中定义了三个不同的号码管理器对象，通过getXXX方法去获取不同的号码管理器对象，实现对号码管理器的管理工作，并且要把此类设计为单例．

 

ServiceWindow类：创建一个start()方法，内部创建了一个线程，不停的循环叫号，通过switch语句，根据不同类型客户，完成窗口叫号、获取任务、服务任务的过程。

 

CustomerType 枚举类：定义三个常量，表示三种不同类型的客户，COMMON,EXPRESS,VIP。

Constants 类：定义三个int类型成员变量，用于时间计算的数据。

MainClass类：通过循环创建几个COMMON类型的窗口，再分别创建EXPRESS,VIP窗口。并通过Executors类的Executors.newScheduledThreadPool(1)创建一个线程池，并调用scheduleAtFixedRate方法，完成号码机器产生新号的过程。

package Default;

 

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

import java.util.concurrent.Executors;

import java.util.concurrent.TimeUnit;

 

public class MainClass {

   public static void main(String[] args) {
      for(int x=1;x<5;x++){//通过循环增加普通窗口．
         ServiceWindow commonservice=new ServiceWindow();
         commonservice.setWindowId(x);
         commonservice.start();
      }

      //增加一个快速窗口
      ServiceWindow expressservice=new ServiceWindow();
      expressservice.setType(CustomerType.EXPRESS);
      expressservice.start();
      //增加一个VIP窗口
      ServiceWindow vipService=new ServiceWindow();
      vipService.setType(CustomerType.VIP);
      vipService.start();
      

      //创建具有一个线程的线程池，并按照固定频率取号模拟产生普通客户．

      Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
            new Runnable(){
                @Override
                publicvoid run() {
                   Integer number=NumberMachine.getInstance().getCommonNumber().generateNumber();
                   System.out.println("第"+number+"号普通客户正在等待服务");
                }               
            },
            0,
            Constants.COMMON_SERVER_INTERVAL_TIME,
            TimeUnit.SECONDS);

      //创建具有一个线程的线程池，并按照固定频率取号模拟产生快速客户．

      Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
            new Runnable(){
                @Override
                publicvoid run() {
                   Integer number=NumberMachine.getInstance().getExpressNumber().generateNumber();
                   System.out.println("第"+number+"号快速客户正在等待服务");
                }               
            },
            0,
            Constants.COMMON_SERVER_INTERVAL_TIME*3,
            TimeUnit.SECONDS);
      //创建具有一个线程的线程池，并按照固定频率取号模拟产生VIP客户．

      Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
            new Runnable(){
                @Override
                publicvoid run() {
                   Integer number=NumberMachine.getInstance().getVipNumber().generateNumber();
                   System.out.println("第"+number+"号VIP客户正在等待服务");
               }               
            },
            0,
            Constants.COMMON_SERVER_INTERVAL_TIME*6,
            TimeUnit.SECONDS);
   }
}

class NumberManager{//定义一个号码管理器类，具有产生号码和取号码的方法．

   //创建一个集合，用于存储号码．

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

   private int LastNumber =1;

   public synchronized Integer generateNumber(){//创建产生号码的方法．

      queneNumber.add(LastNumber);

      return LastNumber++;

   }

   public synchronized Integer fetchServiceNumber(){//创建取出号码的方法．

      Integer number=null;

      if(queneNumber.size()>0){

         number=queneNumber.remove(0);
      }
      return number;
   }
}

class NumberMachine{//号码机器管理号码管理器，因为号码机器只有一个，所以要实现单例．

   private NumberManagercommonNumber=new NumberManager();

   private NumberManagerexpressNumber=new NumberManager();

   private NumberManagervipNumber=new NumberManager();

   //通过getXXX方法，获取不同的号码管理器对象．

   public NumberManager getCommonNumber() {

      return commonNumber;

   }

   public NumberManager getExpressNumber() {

      return expressNumber;

   }

   public NumberManager getVipNumber() {

      return vipNumber;

   }

   //通过以下三步，实现NumberMachine类的单例设计模式．

   private NumberMachine(){}

   private static NumberMachine instance =new NumberMachine();

   public static NumberMachine getInstance(){

      return instance;
   }
}

class ServiceWindow{//定义服务窗口类

   private CustomerTypetype=CustomerType.COMMON;

   private int windowId=1;

   //通过SetXXX方法，实现对窗口的编号和类型设定．

   public void setType(CustomerType type) {

      this.type = type;

   }

   public void setWindowId(int windowId) {

      this.windowId = windowId;

   }

   //定义一个方法，不停循环模拟窗口叫号和获取客户任务，服务客户的过程．

   public void start(){

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

        @Override

         public void run() {

            while(true){

                switch(type){

                caseCOMMON:

                   commonService();

                break;

                caseEXPRESS:

                   expressService(); 

                   break;               

               caseVIP:

                   vipService();  

                   break;

                }

            }

         }        

      });

   }

   private void commonService(){

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

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

      System.out.println(windowname+"正在获取普通任务");

      if(number!=null){

         System.out.println(windowname+"正在为第"+number+"号普通客户服务");

         long begintime=System.currentTimeMillis();

         int maxrandom=Constants.MAX_SERVER_TIME-Constants.MIN_SERVER_TIME;

         long servertime=new Random().nextInt(maxrandom)+1+Constants.MIN_SERVER_TIME;

         try {

            Thread.sleep(servertime);

         } catch (InterruptedException e) {

            e.printStackTrace();

         }

         long costtime=System.currentTimeMillis()-begintime;

         System.out.println(windowname+"完成对第"+number+"号普通客户的服务，耗时"+(costtime/1000)+"秒");

      }else{

         System.out.println(windowname+"没有获取到任务，休息1秒钟");

         try {

            Thread.sleep(1000);

         } catch (InterruptedException e) {

            e.printStackTrace();

         }

      }

   }

   private void expressService() {

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

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

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

      if(number!=null){

         System.out.println(windowname+"正在为第"+number+"号"+type+"客户服务");

         long begintime=System.currentTimeMillis();

         

         try {

            Thread.sleep(Constants.MIN_SERVER_TIME);

         } catch (InterruptedException e) {

            e.printStackTrace();

         }

         long costtime=System.currentTimeMillis()-begintime;

         System.out.println(windowname+"完成对第"+number+"号"+type+"客户的服务，耗时"+(costtime/1000)+"秒");

      }else{

         System.out.println(windowname+"没有获取到任务");

         commonService();

      }

   }

   private void vipService() {

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

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

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

      if(number!=null){

         System.out.println(windowname+"正在为第"+number+"号"+type+"客户服务");

         long begintime=System.currentTimeMillis();

         int maxrandom=Constants.MAX_SERVER_TIME-Constants.MIN_SERVER_TIME;

         long servertime=new Random().nextInt(maxrandom)+1+Constants.MIN_SERVER_TIME;

         try {

            Thread.sleep(servertime);

         } catch (InterruptedException e) {

            e.printStackTrace();

         }

         long costtime=System.currentTimeMillis()-begintime;

         System.out.println(windowname+"完成对第"+number+"号"+type+"客户的服务，耗时"+(costtime/1000)+"秒");

      }else{

         System.out.println(windowname+"没有获取到任务");

         commonService();

      }

   }

}

class Constants{//定义一个类，定义几个常量．

   publicstaticintMAX_SERVER_TIME=10000;

   publicstaticintMIN_SERVER_TIME=1000;

   publicstaticintCOMMON_SERVER_INTERVAL_TIME=1;

         

}

enum CustomerType{//定义一个枚举类，创建三个常量，代表不同类型的客户．并覆盖toString()方法．

   COMMON,EXPRESS,VIP;

   public String toString(){

      switch(this){

      caseCOMMON:

         return"普通";

      caseEXPRESS:

         return"快速";

      caseVIP:

         return"VIP";

      }

      return null;
   }
}

NumberManager类：用于产生号码和获取服务号码，所以定义了产生号码和获取服务号码的方法：generateNumber(),fetchServiceNumber().因为这两个方法操作的都是ArrayList集合中的数据并且这两个方法是由不同的线程来执行的，所以两个方法都需要加上同步．

 

NumberMachine类：这个类中定义了三个不同的号码管理器对象，通过getXXX方法去获取不同的号码管理器对象，实现对号码管理器的管理工作，并且要把此类设计为单例．

 

ServiceWindow类：创建一个start()方法，内部创建了一个线程，不停的循环叫号，通过switch语句，根据不同类型客户，完成窗口叫号、获取任务、服务任务的过程。

 

CustomerType 枚举类：定义三个常量，表示三种不同类型的客户，COMMON,EXPRESS,VIP。

Constants 类：定义三个int类型成员变量，用于时间计算的数据。

MainClass类：通过循环创建几个COMMON类型的窗口，再分别创建EXPRESS,VIP窗口。并通过Executors类的Executors.newScheduledThreadPool(1)创建一个线程池，并调用scheduleAtFixedRate方法，完成号码机器产生新号的过程。