【DataStructure】One of queue usage: Simulation System

Statements: This blog was written by me, but most of content  is quoted from book【Data Structure with Java Hubbard】 

【Description】

This simulationillustrates objectoriented programming(OOP). Java objects are instantiated to represent all the interacting 

clients and servers.To that end, we first define Clientand Serverclasses.This is an event driven simulation, 

where clients arrive for service at random times and services have random durations.

 Each client will have an arrival time, a time when service starts, and a time when it ends. All time values will be integers.

//  Data Structures with Java, Second Edition
//  by John R. Hubbard
//  Copyright 2007 by McGraw-Hill

package com.albertshao.ds.simation;

public class Client {
  private int id;
  private int startTime;

  public Client(int id, int time) {
    this.id = id;
    System.out.printf("%s arrived at time %d.%n", this, time);
  }

  public void setStartTime(int time) {
    startTime = time;
  }

  public String toString() {
    return "#" + id;
  }
}

EachServerobject also stores the time when it will stop serving its current client.That time is

computed by adding its service time (a positive random integer) to the time when it begins serving that

client. The random number generator used togenerate those service times is stored as a randomfield in

the Serverobject. A server’s actual servicetime varies with each client. But the server’s average service

time is a fixed property of the server, initialized when the Serverobject is constructed (at line 10):

//  Data Structures with Java, Second Edition
//  by John R. Hubbard
//  Copyright 2007 by McGraw-Hill

package com.albertshao.ds.simation;

public class Server {
  private Client client;
  private int id;
  private int stopTime = -1;
  private double meanServiceTime;
  private ExpRandom random;

  public Server(int id, double meanServiceTime) {
    this.id = id;
    this.meanServiceTime = meanServiceTime;
    this.random = new ExpRandom(meanServiceTime);
  }

  public double getMeanServiceTime() {
    return meanServiceTime;
  }

  public int getStopTime() {
    return stopTime;
  }

  public boolean isIdle() {
    return client == null;
  }

  public void startServing(Client client, int time) {
    this.client = client;
    this.client.setStartTime(time);
    this.stopTime = time + random.nextInt();
    System.out.printf("%s started serving client %s at time %d, stop time %d.%n",
        this, client, time, this.stopTime);
  }
    
  public void stopServing(int time) {
    System.out.printf("%s stopped serving client %s at time %d.%n",
        this, client, time);
    client = null;
  }

  public String toString() {
    return "Server " + "ABCDEFGHIJKLMNOPQRSTUVWXYZ".charAt(id);
  }
}

For a simulation to be realistic, it must use randomly generated numbers to simulate the natural uncertainty of the real word. Those random numbers should have the same distribution as the natural uncertainties that they represent. Service times and time between client arrivals both tend to be distributed exponentially. That means that the probability that the time tis less than a number xis p= 1 – e-Ox. But the Math.random()method returns numbers that are uniformly distributed in the range 0 dp< 1. So to convert the random number pto the exponentially distributed random variable x, we solve the equation, obtaining x= –(1/O)ln(1 –p). The constant 1/Ois the mean of the distribution. Thus we code the nextDouble()method as shown at line 9：

//  Data Structures with Java, Second Edition
//  by John R. Hubbard
//  Copyright 2007 by McGraw-Hill

package com.albertshao.ds.simation;

public class ExpRandom {
  private double mean;

  public ExpRandom(double mean) {
    this.mean = mean;
  }

  public double nextDouble() {
    return -mean*Math.log(1 - Math.random());
  }

  public int nextInt() {
    return (int)Math.ceil(nextDouble());
  }
}

The actual simulation is performed by the main class shown below. Itsets four constants for the simulation at lines 2–5: the number of servers, the number of clients arrivingfor service, the mean service time among the servers, and the mean timebetween arrivals for the clients.

//  Data Structures with Java, Second Edition
//  by John R. Hubbard
//  Copyright 2007 by McGraw-Hill

package com.albertshao.ds.simation;
import java.util.*;

public class Simulation {
  private static final int SERVERS = 3;
  private static final int CLIENTS = 12;
  private static final int MEAN_SERVICE_TIME = 25;
  private static final int MEAN_ARRIVAL_TIME = 4;
  private static Queue<Client> queue = new ArrayDeque<Client>();
  private static ExpRandom randomService = new ExpRandom(MEAN_SERVICE_TIME);
  private static ExpRandom randomArrival = new ExpRandom(MEAN_ARRIVAL_TIME);
  private static Server[] servers = new Server[SERVERS];
  private static Client[] clients = new Client[CLIENTS];

  public Simulation() {
    String fmt = "%-27s %6d%n";
    System.out.printf(fmt, "Number of servers:", SERVERS);
    System.out.printf(fmt, "Number of clients:", CLIENTS);
    System.out.printf(fmt, "Mean service time:", MEAN_SERVICE_TIME);
    System.out.printf(fmt, "Mean interarrival time:", MEAN_ARRIVAL_TIME);
    for (int i=0; i<SERVERS; i++) {
      double meanServiceTime = randomService.nextDouble();
      servers[i] = new Server(i, meanServiceTime);
      System.out.printf("Mean service time for %s: %4.1f%n",
          servers[i], servers[i].getMeanServiceTime());    
    }
    int nextArrivalTime = 0;
    for (int t=0, clientId=0; clientId < CLIENTS; t++) {
      if (t == nextArrivalTime) {
        nextArrivalTime = t + randomArrival.nextInt();
        Client client = clients[clientId] = new Client(++clientId, t);
        queue.add(client);
        System.out.println("	Client queue: " + queue);
      }
      for (Server server : servers) {
        if (t == server.getStopTime()) {
          server.stopServing(t);
        }
        if (server.isIdle() && !queue.isEmpty()) {
          Client client = (Client)queue.remove();
          System.out.println("	Client queue: " + queue);
          server.startServing(client,t);
        }
      }
    }
  }  

  public static void main(String[] args) {
    new Simulation();
  }
}

The result is :

Number of servers:               3
Number of clients:              12
Mean service time:              25
Mean interarrival time:          4
Mean service time for Server A: 15.3
Mean service time for Server B:  5.3
Mean service time for Server C: 63.0
#1 arrived at time 0.
	Client queue: [#1]
	Client queue: []
Server A started serving client #1 at time 0, stop time 31.
Server A stopped serving client #1 at time 31.
#2 arrived at time 33.
	Client queue: [#2]
	Client queue: []
Server A started serving client #2 at time 33, stop time 61.
#3 arrived at time 38.
	Client queue: [#3]
	Client queue: []
Server B started serving client #3 at time 38, stop time 64.
#4 arrived at time 42.
	Client queue: [#4]
	Client queue: []
Server C started serving client #4 at time 42, stop time 91.
#5 arrived at time 43.
	Client queue: [#5]
#6 arrived at time 44.
	Client queue: [#5, #6]
#7 arrived at time 45.
	Client queue: [#5, #6, #7]
#8 arrived at time 52.
	Client queue: [#5, #6, #7, #8]
#9 arrived at time 53.
	Client queue: [#5, #6, #7, #8, #9]
#10 arrived at time 59.
	Client queue: [#5, #6, #7, #8, #9, #10]
#11 arrived at time 61.
	Client queue: [#5, #6, #7, #8, #9, #10, #11]
Server A stopped serving client #2 at time 61.
	Client queue: [#6, #7, #8, #9, #10, #11]
Server A started serving client #5 at time 61, stop time 80.
Server B stopped serving client #3 at time 64.
	Client queue: [#7, #8, #9, #10, #11]
Server B started serving client #6 at time 64, stop time 65.
Server B stopped serving client #6 at time 65.
	Client queue: [#8, #9, #10, #11]
Server B started serving client #7 at time 65, stop time 70.
#12 arrived at time 70.
	Client queue: [#8, #9, #10, #11, #12]
Server B stopped serving client #7 at time 70.
	Client queue: [#9, #10, #11, #12]
Server B started serving client #8 at time 70, stop time 71.