SSQS

import java.util.*;

class Event {
    int eventType; // 0 for arrival, 1 for departure
    double timestamp;

    public Event(int eventType, double timestamp) {
        this.eventType = eventType;
        this.timestamp = timestamp;
    }
}

class Customer {
    double arrivalTime;
    double serviceTime;

    public Customer(double arrivalTime, double serviceTime) {
        this.arrivalTime = arrivalTime;
        this.serviceTime = serviceTime;
    }
}

public class SingleServerQueueSimulation {
    // System state variables
    int queueLength = 0;
    int numberInService = 0;

    // Entity attributes and sets
    Queue<Customer> customers = new LinkedList<>();

    // Future event list
    PriorityQueue<Event> futureEventList = new PriorityQueue<>(Comparator.comparingDouble(event -> event.timestamp));

    // Activity durations
    double meanInterArrivalTime = 4.5; // minutes
    double meanServiceTime = 3.2; // minutes
    double sigma = 0.6; // standard deviation
    int totalCustomers = 1000;

    // Simulation variables
    double clock = 0.0;
    double totalBusy = 0.0;
    int maxQueueLength = 0;
    double sumResponseTime = 0.0;
    int numberOfDepartures = 0;
    int longService = 0;

    // Summary statistics
    double rho;
    double avgR;
    double pc4;

    // Random number generator
    Random random = new Random();

    public void initialize() {
        // Initialize the simulation with initial events and customer arrivals
        clock = 0.0;
        totalBusy = 0.0;
        maxQueueLength = 0;
        sumResponseTime = 0.0;
        numberOfDepartures = 0;
        longService = 0;

        // Add initial events to the future event list
        futureEventList.offer(new Event(0, exponential(meanInterArrivalTime))); // Initial customer arrival
        futureEventList.offer(new Event(1, Double.POSITIVE_INFINITY)); // Initialize with a departure event (set to infinity)
    }

    public void runSimulation() {
        while (numberOfDepartures < totalCustomers) {
            Event currentEvent = futureEventList.poll();
            clock = currentEvent.timestamp;

            if (currentEvent.eventType == 0) {
                processArrival();
            } else {
                processDeparture();
            }
        }

        // Calculate summary statistics
        rho = totalBusy / clock;
        avgR = sumResponseTime / totalCustomers;
        pc4 = (double) longService / totalCustomers;
    }

    public void processArrival() {
        // Create a new customer with exponential inter-arrival time
        double interArrivalTime = exponential(meanInterArrivalTime);
        Customer customer = new Customer(clock + interArrivalTime, normal(meanServiceTime, sigma));
        
        // Update clock
        clock = customer.arrivalTime;

        // If the server is idle, start service immediately
        if (numberInService == 0) {
            startService(customer);
        } else {
            // Server is busy, customer joins the queue
            queueLength++;
            customers.offer(customer); // Use offer() to enqueue
            maxQueueLength = Math.max(maxQueueLength, queueLength);
        }

        // Schedule the next arrival event
        futureEventList.offer(new Event(0, customer.arrivalTime));
    }

    public void processDeparture() {
        // Update server and queue
        numberInService--;

        // Calculate customer's response time and update statistics
        Customer departingCustomer = customers.remove(); // Use remove() to dequeue
        double responseTime = clock - departingCustomer.arrivalTime;
        sumResponseTime += responseTime;

        if (responseTime >= 4.0) {
            longService++;
        }

        // If there are customers in the queue, start service for the next customer
        if (queueLength > 0) {
            Customer nextCustomer = customers.remove(); // Use remove() to dequeue
            queueLength--;
            startService(nextCustomer);
        }

        // Schedule the next departure event (if applicable)
        if (numberInService > 0) {
            double serviceTime = normal(meanServiceTime, sigma);
            futureEventList.offer(new Event(1, clock + serviceTime));
        }

        numberOfDepartures++;
    }

    public void startService(Customer customer) {
        // Start service for the customer
        numberInService++;

        // Schedule the departure event for this customer
        double serviceTime = normal(meanServiceTime, sigma);
        futureEventList.offer(new Event(1, clock + serviceTime));

        // Update total busy time of the server
        totalBusy += serviceTime;
    }

    public void generateReport() {
        // Generate simulation report with summary statistics
        System.out.println("Simulation Report:");
        System.out.println("RHO (Server Utilization): " + rho);
        System.out.println("Average Response Time (AVGR): " + avgR);
        System.out.println("Proportion of Customers with Service Time >= 4 (PC4): " + pc4);
    }

    // Exponential random number generator
    private double exponential(double mean) {
        return -mean * Math.log(random.nextDouble());
    }

    // Normal random number generator
    private double normal(double mean, double sigma) {
        return mean + sigma * random.nextGaussian();
    }

    public static void main(String[] args) {
        SingleServerQueueSimulation simulation = new SingleServerQueueSimulation();
        simulation.initialize();
        simulation.runSimulation();
        simulation.generateReport();
    }
}