据说7k的Java面试题_银行业务调度系统
模拟实现银行业务调度系统逻辑，具体需求如下：
银行内有6个业务窗口，1- 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。 有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。 异步随机生成各种类型的客户，生成各类型用户的概率比例为：VIP客户 ：普通客户 ：快速客户 = 1 ：6 ：3。
客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间， 快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。 各类型客户在其对应窗口按顺序依次办理业务。 当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务， 而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。 随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。
不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。
前几天看到这上面那篇文章，就有点惊讶，那种题目做出来就7k，我的工资都还没有7k的一半呢？就用C#简单的实现看看，2/3小时就做好了。
以下是具体的代码实现：
View Code
1 public abstract class CAbstractCustomer
2 {
3 public virtual ECustomerType CustomerType
4 {
5 get;
6 private set;
7 }
8
9 public string Name
10 {
11 get;
12 set;
13 }
14 }
抽象的客户类，包含两个属性：客户类型，名称。
客户类型枚举：
View Code
1 public enum ECustomerType
2 {
3 VIPCustomer,
4 GeneralCustomer,
5 FastCustomer
6 }
7
8 public class GetCustomerType
9 {
10 public static string GetName(ECustomerType type)
11 {
12 switch (type)
13 {
14 case ECustomerType.FastCustomer:
15 return "快速客户";
16 case ECustomerType.GeneralCustomer:
17 return "普通客户";
18 case ECustomerType.VIPCustomer:
19 return "VIP客户";
20 }
21 throw new Exception("不存在该客户类型！");
22 }
23 }
VIP客户：
View Code
1 public class CVIPCustomer : CAbstractCustomer
2 {
3 public CVIPCustomer(string name)
4 {
5 base.Name = name;
6 }
7
8 public override ECustomerType CustomerType
9 {
10 get
11 {
12 return ECustomerType.VIPCustomer;
13 }
14 }
15 }
快速客户：
View Code
1 public class CFastCustomer : CAbstractCustomer
2 {
3 public CFastCustomer(string name)
4 {
5 this.Name = name;
6 }
7
8 public override ECustomerType CustomerType
9 {
10 get
11 {
12 return ECustomerType.FastCustomer;
13 }
14 }
15 }
普通客户：
View Code
1 public class CGeneralCustomer : CAbstractCustomer
2 {
3 public CGeneralCustomer(string name)
4 {
5 this.Name = name;
6 }
7
8 public override ECustomerType CustomerType
9 {
10 get
11 {
12 return ECustomerType.GeneralCustomer;
13 }
14 }
15 }
客户生成类：用于动态产生客户
View Code
1 public class CCustomerBuilder:IDisposable
2 {
3 private CCustomerBuilder()
4 {
5 }
6 private static readonly object obj = new object();
7 private static CCustomerBuilder instance = null;
8 public static CCustomerBuilder GetInstance
9 {
10 get
11 {
12 if (instance == null)
13 {
14 lock (obj)
15 {
16 if (instance == null)
17 {
18 instance = new CCustomerBuilder();
19 }
20 }
21 }
22 return instance;
23 }
24 }
25 private const double BuildTime = 2000;
26 //VIP客户：普通客户：快速客户 = 1 ：6 ：3。转化为普通客户每2秒生成一个，VIP客户12秒生成一个，快速客户4秒生成一个
27 private static Timer VIPTimer = new Timer(BuildTime * 6.0);
28 private static Timer GeneralTimer = new Timer(BuildTime);
29 private static Timer FastTimer = new Timer(BuildTime*2.0);
30 private static int generalCount = 0;
31 private static int fastCount = 0;
32 private static int vipCount = 0;
33 static CCustomerBuilder()
34 {
35 FastTimer.Elapsed += new ElapsedEventHandler(FastTimer_Elapsed);
36 VIPTimer.Elapsed += new ElapsedEventHandler(VIPTimer_Elapsed);
37 GeneralTimer.Elapsed += new ElapsedEventHandler(GeneralTimer_Elapsed);
38 }
39 public static string GetGeneralNextNum()
40 {
41 generalCount = ++generalCount;
42 return generalCount.ToString();
43 }
44 public static string GetFastNextNum()
45 {
46 fastCount = ++fastCount;
47 return fastCount.ToString();
48 }
49 public static string GetVipNextNum()
50 {
51 vipCount = ++vipCount;
52 return vipCount.ToString();
53 }
54 static void GeneralTimer_Elapsed(object sender, ElapsedEventArgs e)
55 {
56 CGeneralCustomerDispatcher.GetInstance.GeneralCustomerEnqueue(new CGeneralCustomer(GetCustomerType.GetName(ECustomerType.GeneralCustomer) + GetGeneralNextNum()));
57 }
58
59 static void VIPTimer_Elapsed(object sender, ElapsedEventArgs e)
60 {
61 CVIPCustomerDispatcher.GetInstance.VIPCustomerEnqueue(new CVIPCustomer(GetCustomerType.GetName(ECustomerType.VIPCustomer) + GetVipNextNum()));
62 }
63
64 static void FastTimer_Elapsed(object sender, ElapsedEventArgs e)
65 {
66 CFastCustomerDispatcher.GetInstance.FastCustomerEnqueue(new CFastCustomer(GetCustomerType.GetName(ECustomerType.FastCustomer) + GetFastNextNum()));
67 }
68
69 public void TimerStart()
70 {
71 FastTimer.Start();
72 VIPTimer.Start();
73 GeneralTimer.Start();
74 }
75 public void TimerStop()
76 {
77 FastTimer.Stop();
78 VIPTimer.Stop();
79 GeneralTimer.Stop();
80 }
81
82 #region IDisposable 成员
83
84 public void Dispose()
85 {
86 this.TimerStop();
87 if (FastTimer != null)
88 {
89 FastTimer.Dispose();
90 }
91 if (VIPTimer != null)
92 {
93 VIPTimer.Dispose();
94 }
95 if (GeneralTimer != null)
96 {
97 GeneralTimer.Dispose();
98 }
99 }
100
101 #endregion
102 }
不同类型的客户队列调度类：
View Code
1 /// <summary>
2 /// 快速客户队列
3 /// </summary>
4 public class CFastCustomerDispatcher : IDispatcher,IDisposable
5 {
6 private CFastCustomerDispatcher()
7 { }
8 ~CFastCustomerDispatcher()
9 {
10 this.Dispose();
11 }
12 private static readonly object lockObj = new object();
13 private static CFastCustomerDispatcher dispatcher = null;
14 public static CFastCustomerDispatcher GetInstance
15 {
16 get
17 {
18 if (dispatcher == null)
19 {
20 lock (lockObj)
21 {
22 if (dispatcher == null)
23 {
24 dispatcher = new CFastCustomerDispatcher();
25 }
26 }
27 }
28 return dispatcher;
29 }
30 }
31 private static Queue<CAbstractCustomer> fastList = null;
32 static CFastCustomerDispatcher()
33 {
34 fastList = new Queue<CAbstractCustomer>();
35 }
36 [DebuggerStepThrough]
37 public void FastCustomerEnqueue(CAbstractCustomer customer)
38 {
39 lock (lockObj)
40 {
41 fastList.Enqueue(customer);
42 }
43 }
44 [DebuggerStepThrough]
45 public CAbstractCustomer FastCustomerDequeue()
46 {
47 lock (lockObj)
48 {
49 if (fastList.Count > 0)
50 {
51 return fastList.Dequeue();
52 }
53 }
54 return null;
55 }
56
57 public int Count
58 {
59 get
60 {
61 return fastList.Count;
62 }
63 }
64
65 #region IDisposable 成员
66
67 public void Dispose()
68 {
69 dispatcher = null;
70 if (fastList != null)
71 {
72 fastList.Clear();
73 fastList = null;
74 }
75 }
76
77 #endregion
78 }
View Code
1 /// <summary>
2 /// vip客户队列
3 /// </summary>
4 public class CVIPCustomerDispatcher : IDispatcher,IDisposable
5 {
6 private CVIPCustomerDispatcher()
7 { }
8 ~CVIPCustomerDispatcher()
9 {
10 this.Dispose();
11 }
12 private static readonly object lockObj = new object();
13 private static CVIPCustomerDispatcher dispatcher = null;
14
15 public static CVIPCustomerDispatcher GetInstance
16 {
17 get
18 {
19 if (dispatcher == null)
20 {
21 lock (lockObj)
22 {
23 if (dispatcher == null)
24 {
25 dispatcher = new CVIPCustomerDispatcher();
26 }
27 }
28 }
29 return dispatcher;
30 }
31 }
32
33 private static Queue<CAbstractCustomer> vipList = null;
34 static CVIPCustomerDispatcher()
35 {
36 vipList = new Queue<CAbstractCustomer>();
37 }
38 [DebuggerStepThrough]
39 public void VIPCustomerEnqueue(CAbstractCustomer customer)
40 {
41 lock (lockObj)
42 {
43 vipList.Enqueue(customer);
44 }
45 }
46 [DebuggerStepThrough]
47 public CAbstractCustomer VIPCustomerDequeue()
48 {
49 lock (lockObj)
50 {
51 if (vipList.Count > 0)
52 {
53 return vipList.Dequeue();
54 }
55 }
56 return null;
57 }
58
59 public int Count
60 {
61 get
62 {
63 return vipList.Count;
64 }
65 }
66
67 #region IDisposable 成员
68
69 public void Dispose()
70 {
71 dispatcher = null;
72 if (vipList != null)
73 {
74 vipList.Clear();
75 vipList = null;
76 }
77 }
78
79 #endregion
80 }
View Code
1 /// <summary>
2 /// 普通客户队列
3 /// </summary>
4 public class CGeneralCustomerDispatcher : IDispatcher,IDisposable
5 {
6 private CGeneralCustomerDispatcher()
7 { }
8 ~CGeneralCustomerDispatcher()
9 {
10 this.Dispose();
11 }
12 private static readonly object lockObj = new object();
13 private static CGeneralCustomerDispatcher dispatcher = null;
14 public static CGeneralCustomerDispatcher GetInstance
15 {
16 get
17 {
18 if (dispatcher == null)
19 {
20 lock (lockObj)
21 {
22 if (dispatcher == null)
23 {
24 dispatcher = new CGeneralCustomerDispatcher();
25 }
26 }
27 }
28 return dispatcher;
29 }
30 }
31
32 private static Queue<CAbstractCustomer> generalList = null;
33 static CGeneralCustomerDispatcher()
34 {
35 generalList = new Queue<CAbstractCustomer>();
36 }
37 [DebuggerStepThrough]
38 public void GeneralCustomerEnqueue(CAbstractCustomer customer)
39 {
40 lock (lockObj)
41 {
42 generalList.Enqueue(customer);
43 }
44 }
45 [DebuggerStepThrough]
46 public CAbstractCustomer GeneralCustomerDequeue()
47 {
48 lock (lockObj)
49 {
50 if (generalList.Count > 0)
51 {
52 return generalList.Dequeue();
53 }
54 }
55 return null;
56 }
57
58 public int Count
59 {
60 get
61 {
62 return generalList.Count;
63 }
64 }
65
66 #region IDisposable 成员
67
68 public void Dispose()
69 {
70 dispatcher = null;
71 if (generalList != null)
72 {
73 generalList.Clear();
74 generalList = null;
75 }
76 }
77
78 #endregion
79 }
服务窗口类：
View Code
1 public class CServiceWindow
2 {
3 private const int MIN_SERVICE_TIME = 10000;
4 private const int MAX_SERVICE_TIME = 60000;
5 public string ID
6 {
7 get;
8 set;
9 }
10
11 public EWindowType WindowType
12 {
13 get;
14 set;
15 }
16
17 public void StartDoWork()
18 {
19 DateTime now = DateTime.Now;
20 do
21 {
22
23 switch (WindowType)
24 {
25 case EWindowType.GeneralWindow:
26 ProcessGeneralCustomer(EWindowType.GeneralWindow);
27 break;
28
29 case EWindowType.VIPWindow:
30 ProcessVIPCustomer();
31 break;
32
33 case EWindowType.FastWindow:
34 ProcessFastCustomer();
35 break;
36 }
37
38 if (DateTime.Now.Subtract(now).Minutes >5)//执行5分钟后退出业务，银行关门
39 {
40 CCustomerBuilder.GetInstance.Dispose();
41 Console.WriteLine("银行关门时间到了，" +this.ID+ GetWindowType.GetName(WindowType) + "停止服务！");
42 break;
43 }
44 }
45 while (true);
46 }
47
48 /// <summary>
49 /// 快速客户办理业务所需时间为最小值 VIP和普通客户在最大值和最小值之间随机取值
50 /// </summary>
51 private void ProcessFastCustomer()
52 {
53 if (CFastCustomerDispatcher.GetInstance.Count == 0)//快速客户为空可以处理普通客户
54 {
55 this.ProcessGeneralCustomer(EWindowType.FastWindow);
56 }
57 else
58 {
59 Random r = new Random();
60 CFastCustomer customer = CFastCustomerDispatcher.GetInstance.FastCustomerDequeue() as CFastCustomer;
61 if (customer != null)
62 {
63 string winName=GetWindowType.GetName(EWindowType.FastWindow);
64 Console.BackgroundColor = ConsoleColor.Blue;
65 Console.WriteLine(this.ID + "号" + winName + " 呼叫客户:" + customer.Name);
66 Console.BackgroundColor = ConsoleColor.Blue;
67 Console.WriteLine(this.ID + "号" + winName + " 正在办理,请稍候......!");
68 int time = r.Next(MIN_SERVICE_TIME);
69 System.Threading.Thread.Sleep(time);
70 Console.BackgroundColor = ConsoleColor.Blue;
71 Console.WriteLine(this.ID + "号" + winName + " " + customer.Name + " 办理完成！\n");
72 }
73 else
74 {
75 System.Threading.Thread.Sleep(2000);//当前队列为空，休息2秒在叫号
76 }
77 }
78 }
79
80 private void ProcessVIPCustomer()
81 {
82 if (CVIPCustomerDispatcher.GetInstance.Count == 0)//vip客户为空可以处理普通客户
83 {
84 this.ProcessGeneralCustomer(EWindowType.VIPWindow);
85 }
86 else
87 {
88 Random r = new Random();
89 CVIPCustomer customer = CVIPCustomerDispatcher.GetInstance.VIPCustomerDequeue() as CVIPCustomer;
90 if (customer != null)
91 {
92 string winName = GetWindowType.GetName(EWindowType.VIPWindow);
93 Console.BackgroundColor = ConsoleColor.White;
94 Console.WriteLine(this.ID + "号"+winName+" 呼叫客户:" + customer.Name);
95 Console.BackgroundColor = ConsoleColor.White;
96 Console.WriteLine(this.ID + "号"+winName+" 正在办理,请稍候......!");
97 int time = r.Next(MIN_SERVICE_TIME, MAX_SERVICE_TIME);
98 System.Threading.Thread.Sleep(time);
99 Console.BackgroundColor = ConsoleColor.White;
100 Console.WriteLine(this.ID + "号"+winName+" " + customer.Name + " 办理完成！\n");
101 }
102 else
103 {
104 System.Threading.Thread.Sleep(2000);//当前队列为空，休息2秒在叫号
105 }
106 }
107 }
108
109 private void ProcessGeneralCustomer(EWindowType type)
110 {
111 Random r = new Random();
112 CGeneralCustomer customer = CGeneralCustomerDispatcher.GetInstance.GeneralCustomerDequeue() as CGeneralCustomer;
113 if (customer != null)
114 {
115 string winName = GetWindowType.GetName(type);
116 Console.BackgroundColor = ConsoleColor.DarkRed;
117 Console.WriteLine(this.ID + "号" + winName + " 呼叫客户:" + customer.Name);
118 Console.BackgroundColor = ConsoleColor.DarkRed;
119 Console.WriteLine(this.ID + "号" + winName + " 正在办理!请稍候..!");
120 int time = r.Next(MIN_SERVICE_TIME, MAX_SERVICE_TIME);
121 System.Threading.Thread.Sleep(time);
122 Console.BackgroundColor = ConsoleColor.DarkRed;
123 Console.WriteLine(this.ID + "号" + winName + " " + customer.Name + " 办理完成！\n");
124 }
125 else
126 {
127 System.Threading.Thread.Sleep(2000);//当前队列为空，休息2秒在叫号
128 }
129 }
130 }
窗口类别类：
View Code
1 public enum ECustomerType
2 {
3 VIPCustomer,
4 GeneralCustomer,
5 FastCustomer
6 }
7
8 public class GetCustomerType
9 {
10 public static string GetName(ECustomerType type)
11 {
12 switch (type)
13 {
14 case ECustomerType.FastCustomer:
15 return "快速客户";
16 case ECustomerType.GeneralCustomer:
17 return "普通客户";
18 case ECustomerType.VIPCustomer:
19 return "VIP客户";
20 }
21 throw new Exception("不存在该客户类型！");
22 }
23 }
主函数：
View Code
1 static void Main(string[] args)
2 {
3 CCustomerBuilder.GetInstance.TimerStart();
4 Thread t1 = new Thread(() =>
5 {
6 CServiceWindow window = new CServiceWindow();
7 window.WindowType = EWindowType.GeneralWindow;
8 window.ID = "1";
9 window.StartDoWork();
10 });
11 t1.Start();
12
13 Thread t2 = new Thread(() =>
14 {
15 CServiceWindow window = new CServiceWindow();
16 window.WindowType = EWindowType.GeneralWindow;
17 window.ID = "2";
18 window.StartDoWork();
19 });
20 t2.Start();
21
22 Thread t3 = new Thread(() =>
23 {
24 CServiceWindow window = new CServiceWindow();
25 window.WindowType = EWindowType.GeneralWindow;
26 window.ID = "3";
27 window.StartDoWork();
28 });
29 t3.Start();
30
31 Thread t4 = new Thread(() =>
32 {
33 CServiceWindow window = new CServiceWindow();
34 window.WindowType = EWindowType.GeneralWindow;
35 window.ID = "4";
36 window.StartDoWork();
37 });
38 t4.Start();
39
40 Thread vipThread = new Thread(() =>
41 {
42 CServiceWindow vipWindow = new CServiceWindow();
43 vipWindow.WindowType = EWindowType.VIPWindow;
44 vipWindow.ID = "5";
45 vipWindow.StartDoWork();
46 });
47 vipThread.Start();
48
49 Thread fastThread = new Thread(() =>
50 {
51 CServiceWindow fastWindow = new CServiceWindow();
52 fastWindow.WindowType = EWindowType.FastWindow;
53 fastWindow.ID = "6";
54 fastWindow.StartDoWork();
55 });
56 fastThread.Start();
57
58 Console.ReadLine();
59 }
