SingleQueue

import java.util.*;


public class SingleQueue {

        final static int arrivalTimeLimit = 3600; // set the arrival time limit in seconds
        final static double arrivalProbability = 1.0/10; // Probability a request will arrive at any given second
        final static int numberOfServers = 5; // set the number of servers available to process the queue


        public static void main(String[] args) {
                Queue<Request> queue = new Queue<Request>();
                Random checkArrival = new Random();
                int totalWaitTime = 0;
                int totalServed = 0;
                int [] serverArray = new int[numberOfServers];

                //
                // In the simulation, we simulate each second of time.  We continue the simulation until we reach
                // the time limit and the queue is empty.
                //
                for (int currentSecond = 1; currentSecond <= arrivalTimeLimit || queue.size() > 0; currentSecond++) {
                        // System.out.println(currentSecond);
                        //
                        // If the number of seconds has not exceeded the time after which no one is allowed to queue up,
                        // check whether someone has arrived.  If so, put their arrival time on the queue.
                        //
                        if (currentSecond <= arrivalTimeLimit) {
                                boolean arrivalHappened = (checkArrival.nextDouble() <= arrivalProbability);
                                if (arrivalHappened) {
                                        Random setTimeToServe = new Random(); // creates a random object to generate a random timeToServe for each request
                                        int timeToServe = setTimeToServe.nextInt(49) + 10;
                                        Request newRequest = new Request(currentSecond, timeToServe);
                                        queue.enqueue(newRequest);
                                }
                        }

                        for (int server = 0; server < numberOfServers; server++){
                                //
                                // If someone is currently being served, decrement the time remaining to serve by 1.
                                // Do this if server is serving
                                if (serverArray[server] > 0) {
                                        serverArray[server]--;
                                }
                                //
                                // Otherwise no one is being served.  Check whether anyone is waiting on the queue and,
                                // if so, begin serving them.  Add their wait to time to the total wait time and increment
                                // the number served.
                                //
                                else if (queue.size() > 0) {
                                        Request processRequest = queue.dequeue();
                                        serverArray[server] = processRequest.serviceTime;
                                        int arrivalTime = processRequest.arrivalTime;
                                        int waitTime = currentSecond - arrivalTime;
                                        totalWaitTime += waitTime;
                                        totalServed++;

                                }
                        }
                }
                System.out.println("Number served: " + totalServed);
                System.out.println("Total wait time: " + totalWaitTime);
                System.out.println("Average wait time: " + (double)totalWaitTime/totalServed);

        }
}