Design a Real-Time Queue Management System Using OOD Principles

Real-Time Queue Management System Design Using Object-Oriented Design (OOD)

A real-time queue management system is crucial for efficiently managing queues in various environments, such as hospitals, banks, airports, or customer service centers. By utilizing object-oriented design (OOD) principles, this system can be modular, extensible, and easy to maintain. Below is a breakdown of how such a system can be structured using OOD principles.

1. Identify Key Requirements and Entities

To design the system, we first need to identify key requirements and the entities involved in the queue management system. The primary goal is to manage the flow of customers or users in a queue, assign resources to them, and notify them about their position in the queue.

Key Requirements:

Real-time queue updates.
Assigning customers to available service agents.
Handling customer priorities.
Notifications to customers regarding their position.
Dynamic handling of arrival and departure of customers.
Statistics and reporting features (e.g., average wait time, number of customers served).

Entities:

Customer: Represents an individual in the queue.
Queue: The data structure holding customers in line.
ServiceAgent: Represents an agent or server who will attend to customers.
QueueManager: Manages and controls the entire queue system.
NotificationService: Sends updates and notifications to customers.
PriorityQueue: A specialized queue with priority handling.

2. Class Design

We will define the main classes for the system, keeping OOD principles such as abstraction, encapsulation, inheritance, and polymorphism in mind.

2.1. Class: Customer

The Customer class represents an individual waiting in the queue. It includes details such as the customer’s ID, name, arrival time, and priority level.

python
class Customer:
    def __init__(self, customer_id, name, arrival_time, priority=1):
        self.customer_id = customer_id
        self.name = name
        self.arrival_time = arrival_time
        self.priority = priority
        self.served_time = None

    def get_wait_time(self, current_time):
        if self.served_time:
            return self.served_time - self.arrival_time
        return current_time - self.arrival_time

    def __str__(self):
        return f"Customer {self.customer_id}: {self.name} (Priority: {self.priority})"

2.2. Class: ServiceAgent

The ServiceAgent class represents an individual who serves customers in the queue.

python
class ServiceAgent:
    def __init__(self, agent_id, name):
        self.agent_id = agent_id
        self.name = name
        self.is_available = True

    def assign_customer(self, customer):
        if self.is_available:
            self.is_available = False
            print(f"{self.name} is now serving {customer.name}.")
            return True
        return False

    def release_customer(self):
        self.is_available = True

2.3. Class: Queue

The Queue class manages the line of customers waiting for service. We will use a priority queue to handle customers with different priorities.

python
import heapq

class Queue:
    def __init__(self):
        self.customers = []
        self.customer_map = {}

    def add_customer(self, customer):
        heapq.heappush(self.customers, (customer.priority, customer))
        self.customer_map[customer.customer_id] = customer

    def remove_customer(self, customer_id):
        customer = self.customer_map.pop(customer_id, None)
        if customer:
            self.customers.remove((customer.priority, customer))
            heapq.heapify(self.customers)

    def get_next_customer(self):
        if self.customers:
            return heapq.heappop(self.customers)[1]
        return None

2.4. Class: QueueManager

The QueueManager class oversees the entire queue system. It controls the flow of customers and assigns them to available service agents.

python
class QueueManager:
    def __init__(self):
        self.queue = Queue()
        self.agents = []
        self.notification_service = NotificationService()

    def add_agent(self, agent):
        self.agents.append(agent)

    def add_customer_to_queue(self, customer):
        self.queue.add_customer(customer)
        self.notification_service.notify_arrival(customer)

    def assign_customer_to_agent(self):
        for agent in self.agents:
            if agent.is_available:
                next_customer = self.queue.get_next_customer()
                if next_customer:
                    agent.assign_customer(next_customer)
                    next_customer.served_time = time.time()
                    self.notification_service.notify_serving(next_customer, agent)

    def release_customer_from_agent(self, agent):
        agent.release_customer()

2.5. Class: NotificationService

This class handles notifications to customers about their status in the queue.

python
class NotificationService:
    def notify_arrival(self, customer):
        print(f"Notification: {customer.name} has joined the queue.")

    def notify_serving(self, customer, agent):
        print(f"Notification: {customer.name} is being served by {agent.name}.")

    def notify_position(self, customer, position):
        print(f"Notification: {customer.name}, you are now in position {position}.")

3. System Workflow

Customer Arrival:
- When a customer arrives, they are added to the queue based on their priority.
- The system assigns an available service agent to the next customer in line.
Customer Service:
- A service agent becomes available after serving a customer. The agent will be assigned to the next customer in the queue.
Queue Notification:
- Customers are notified when they join the queue, when they are being served, and about their position in the queue.
Release and Completion:
- Once a service agent completes serving a customer, the agent is released, and the next customer is assigned to them.

4. Advanced Features

4.1. Prioritization Mechanism

The system supports different levels of priorities for customers. For instance, VIP customers can have a higher priority than regular customers. This is managed using the priority attribute in the Customer class.

4.2. Real-Time Statistics

The system can collect statistics such as the average waiting time, the number of customers served, and the number of customers in the queue. This data can be stored and analyzed for future improvements.

4.3. Scalability

The system can scale to handle more service agents and customers by adjusting the size of the queue and adding more agents to the QueueManager.

4.4. Mobile or Web Notifications

Notifications can be sent in real-time via SMS, email, or a mobile app, keeping customers updated about their queue status.

5. UML Diagram

A UML diagram can be used to represent the structure of the classes and their relationships.

Customer → Holds customer data and priority.
Queue → Manages the line and serves customers in priority order.
QueueManager → Manages queue flow and agent assignments.
ServiceAgent → Represents individuals serving customers.
NotificationService → Sends notifications to customers.

Conclusion

The real-time queue management system designed using OOD principles provides an efficient, scalable solution for handling customer queues. The system is modular, with distinct responsibilities assigned to each class, making it easy to extend or modify in the future. The use of priority queues and notifications ensures customers are efficiently served, and they are kept informed throughout their wait.

Share this Page your favorite way: Click any app below to share.

See all the ways to share this page