模拟超时排队系统

marketmodel.py 

#! /usr/bin/env python
# _*_: utf-8 _*_

from cashier import Cashier
from customer import Customer

class MarketModel(object):

	def __init__(self, lenthofSimulation, averageTimePerCus,
	             probabilityOfNewArrival):
		self._probabilityofNewArrival = probabilityOfNewArrival
		self._lengthOfSimulation = lenthofSimulation
		self._averageTimePerCus = averageTimePerCus
		self._cashier = Cashier()

	def runSimulation(self):
		"""Run the clock for n ticks"""
		for currentTime in range(self._lengthOfSimulation):
			# Attempt to generate a new customer
			customer = Customer.generateCustomer(
				self._probabilityofNewArrival,
				currentTime,
				self._averageTimePerCus
			)
			# Send customer to cashier if successfully
			# generated
			if customer != None:
				self._cashier.addCustomer(customer)

			# Tell casheir to provide another unit of service
			self._cashier.serveCustomers(currentTime)

	def __str__(self):
		return str(self._cashier)

cashier.py

#! /usr/bin/env python
# -*- coding: utf-8 -*-

'''
@author: liudaoqiang
@file: studycase
@time: 2018/9/11 20:49
'''
"""
File: cashier.py
"""
from queue import LoopArrayQueue
from queue import LinkedQueue

class Cashier(object):

	def __init__(self):
		self._totalCustomerWaitTime = 0
		self._customerServed = 0
		self._currentCustomer = None
		self._queue = LinkedQueue()

	def addCustomer(self, c):
		self._queue.add(c)

	def serveCustomers(self, currentTime):
		if self._currentCustomer is None:
			# No customer yet
			if self._queue.isEmpty():
				return
			else:
				# Pop first waiting customer
				# and totally results
				self._currentCustomer = self._queue.pop()
				self._totalCustomerWaitTime += currentTime -\
					self._currentCustomer.arrivalTime()
				self._customerServed += 1

			# Give a unit of service
			self._currentCustomer.serve()

			# if current customer is finished, send it away
			if self._currentCustomer.amountOfServiceNeeded() == 0:
				self._currentCustomer = None

	def __str__(self):
		result = "TOTALS FOR THE CASHIER\n" +\
			"Number of customers served:" +\
			str(self._customerServed) + "\n"

		if self._customerServed != 0:
			aveWaitTime = self._totalCustomerWaitTime / self._customerServed
			result += "Number of customers left in queue:" \
				+ str(len(self._queue)) + "\n" +\
					"Average time customers spend\n" +\
					"waiting to be served: "\
					+ "%5.2f" % aveWaitTime
		return result

customer.py

#! /usr/bin/env python
# -*- coding: utf-8 -*-

'''
@author: liudaoqiang
@file: studycase
@time: 2018/9/11 21:16
'''
"""
File: customer.py
"""

import random

class Customer(object):

	@classmethod
	def generateCustomer(cls, probabilityOfNewArrival,
	                     arrivalTime, averageTimePerCustomer):
		"""
		Return a Customer object if the probability
		of arrival is greater than or equal to a random number
		Otherwise, returns None, indicating no new customer
		:param probabilityOfNewArrival:
		:param arrivalTime:
		:param averageTimePerCustomer:
		:return:
		"""
		if random.random() <= probabilityOfNewArrival:
			return Customer(arrivalTime, averageTimePerCustomer)
		else:
			return None

	def __init__(self, arrivalTime, serviceNeeded):
		self._arrivalTime = arrivalTime
		self._amountOfServiceNeeded = serviceNeeded

	def  arrivalTime(self):
		return self._arrivalTime

	def amountOfServiceNeeded(self):
		return self._amountOfServiceNeeded

	def serve(self):
		"""Accepts a unit of service from the cashier"""
		self._amountOfServiceNeeded -= 1