Warum fügt es jedes Mal dem letzten hinzu, wenn ich mein Programm starte?

Question

Grundsätzlich ist die Frage, eine Simulation für Leute zu erstellen, die in einer Bank Schlange stehen. Es gibt bestimmte Kriterien wie durchschnittliche Wartezeit, durchschnittliche Anzahl der Minuten, durchschnittliche längste Wartezeit ... usw. Es wird auch gebeten, mein Programm dreimal pro 1000 Mal auszuführen (mit einer for-Schleife). Das Problem ist, dass jedes Mal, wenn ich den Code ausführe, die Antworten aus irgendeinem Grund aufgehen und ich nicht zu wissen vermag, warum. Im letzten Durchlauf sollte die Anzahl der ausgeführten Simulationen beispielsweise 1000 Mal betragen, stattdessen wurden alle vorherigen Läufe zusammen addiert und 3000 Mal angegeben.

Auch alle Variablen außerhalb der While-Schleife (AverageWaitingTime, AverageSimulationTime ... etc) geben mir falsche Antworten. Zum Beispiel, weil für die durchschnittliche Wartezeit der gleiche Wert der Wartezeit addiert wird. Ich kann nicht herausfinden warum.

public class QueueSimulation { 
    public static void main(String[] args) { 
    Queue<Customer> q = new LinkedList<Customer>(); 

    int numServed = 0; 
    int averageNumServed = 0; 
    int waitingTime = 0; 
    int maxWaitingTime = 0; 
    int averageLongestWaitingTime = 0; 
    int totalWaitingTime = 0; 
    double averageWaitingTime = 0; 
    int maxQueueSize = 0; 
    int timeDone = 0; 
    int totalSimulationTime = 0; 
    int averageSimulationTime = 0; 
    int numSimulationRan = 0; 
    Random randomGenerator = new Random(); 
    int time = 0; 
    int processingTime = 0; 
    int totalProcessingTime = 0; 

    for (int i = 0; i < 1000; i++) { 

     double arrivalRate = 0.2; 
     int maxProcessingTime = 5; 

     while (time < 8 * 60) { 
      if (Math.random() < 0.2) { 
       System.out.println("A new customer arrives at time " + time); 
       processingTime = randomGenerator.nextInt(maxProcessingTime); 
       totalProcessingTime += processingTime; 
       Customer c = new Customer(time, processingTime); 
       q.add(c); 
       if (q.size() > maxQueueSize) 
        maxQueueSize = q.size(); 
      } 

      if (waitingTime > maxWaitingTime) 
       maxWaitingTime = waitingTime; 

      averageLongestWaitingTime += maxWaitingTime; 

      // serve the next customer 
      if (time > timeDone) // service is available 
       if (!q.isEmpty()) { 
        Customer c = q.remove(); 
        timeDone = time + c.getProcessingTime(); 
        // calculate the waiting time of this customer 
        waitingTime = time - c.getArrivalTime(); 
        // update total waiting time of all customers 
        totalWaitingTime += waitingTime; 
        // service this customer 
        numServed++; 
       } 
      time++; 

      if (time > 8 * 60) 
       while (!q.isEmpty()) { 
        Customer c = q.remove(); 
        timeDone = time + c.getProcessingTime(); 
        // calculate the waiting time of this customer 
        waitingTime = time - c.getArrivalTime(); 
        // update total waiting time of all customers 
        totalWaitingTime += waitingTime; 
        // service this customer 
        numServed++; 
       } 
     } 

     averageWaitingTime += (totalWaitingTime/numServed); 
     totalSimulationTime = timeDone; 
     averageSimulationTime += totalSimulationTime; 
     averageNumServed += numServed; 
     numSimulationRan += 1; 
    } 

    System.out.println(); 
    System.out.println("Average waiting time per customer: " + (double) averageWaitingTime/1000); 
    System.out.println("Average longest waiting time: " + (double) averageLongestWaitingTime/1000); 
    System.out.println("Average number of minutes: " + (double) averageSimulationTime/1000); 
    System.out.println("Longest waiting time: " + maxWaitingTime); 
    System.out.println("Average number of customers " + (double) averageNumServed/1000); 
    System.out.println("Number of times the simulation ran: " + numSimulationRan); 

    for (int j = 0; j < 1000; j++) { 

     double arrivalRate = 0.5; 
     int maxProcessingTime = 3; 

     while (time < 8 * 60) { 
      if (Math.random() < 0.5) { 
       System.out.println("A new customer arrives at time " + time); 
       processingTime = randomGenerator.nextInt(maxProcessingTime); 
       totalProcessingTime += processingTime; 
       Customer c = new Customer(time, processingTime); 
       q.add(c); 
       if (q.size() > maxQueueSize) 
        maxQueueSize = q.size(); 
      } 

      if (waitingTime > maxWaitingTime) 
       maxWaitingTime = waitingTime; 

      averageLongestWaitingTime += maxWaitingTime; 

      // serve the next customer 
      if (time > timeDone) // service is available 
       if (!q.isEmpty()) { 
        Customer c = q.remove(); 
        timeDone = time + c.getProcessingTime(); 
        // calculate the waiting time of this customer 
        waitingTime = time - c.getArrivalTime(); 
        // update total waiting time of all customers 
        totalWaitingTime += waitingTime; 
        // service this customer 
        numServed++; 
       } 
      time++; 

      if (time > 8 * 60) 
       while (!q.isEmpty()) { 
        Customer c = q.remove(); 
        timeDone = time + c.getProcessingTime(); 
        // calculate the waiting time of this customer 
        waitingTime = time - c.getArrivalTime(); 
        // update total waiting time of all customers 
        totalWaitingTime += waitingTime; 
        // service this customer 
        numServed++; 
       } 
     } 

     averageWaitingTime += (totalWaitingTime/numServed); 
     totalSimulationTime = timeDone; 
     averageSimulationTime += totalSimulationTime; 
     averageNumServed += numServed; 
     numSimulationRan += 1; 
    } 

    System.out.println(); 
    System.out.println("Average waiting time per customer: " + (double) averageWaitingTime/1000); 
    System.out.println("Average longest waiting time: " + (double) averageLongestWaitingTime/1000); 
    System.out.println("Average number of minutes: " + (double) averageSimulationTime/1000); 
    System.out.println("Longest waiting time: " + maxWaitingTime); 
    System.out.println("Average number of customers " + (double) averageNumServed/1000); 
    System.out.println("Number of times the simulation ran: " + numSimulationRan); 

    for (int k = 0; k < 1000; k++) { 

     double arrivalRate = 0.68; 
     int maxProcessingTime = 4; 

     while (time < 8 * 60) { 
      if (Math.random() < 0.68) { 
       System.out.println("A new customer arrives at time " + time); 
       processingTime = randomGenerator.nextInt(maxProcessingTime); 
       totalProcessingTime += processingTime; 
       Customer c = new Customer(time, processingTime); 
       q.add(c); 
       if (q.size() > maxQueueSize) 
        maxQueueSize = q.size(); 
      } 

      if (waitingTime > maxWaitingTime) 
       maxWaitingTime = waitingTime; 

      averageLongestWaitingTime += maxWaitingTime; 

      // serve the next customer 
      if (time > timeDone) // service is available 
       if (!q.isEmpty()) { 
        Customer c = q.remove(); 
        timeDone = time + c.getProcessingTime(); 
        // calculate the waiting time of this customer 
        waitingTime = time - c.getArrivalTime(); 
        // update total waiting time of all customers 
        totalWaitingTime += waitingTime; 
        // service this customer 
        numServed++; 
       } 
      time++; 

      if (time > 8 * 60) 
       while (!q.isEmpty()) { 
        Customer c = q.remove(); 
        timeDone = time + c.getProcessingTime(); 
        // calculate the waiting time of this customer 
        waitingTime = time - c.getArrivalTime(); 
        // update total waiting time of all customers 
        totalWaitingTime += waitingTime; 
        // service this customer 
        numServed++; 
       } 
     } 

     averageWaitingTime += (totalWaitingTime/numServed); 
     totalSimulationTime = timeDone; 
     averageSimulationTime += totalSimulationTime; 
     averageNumServed += numServed; 
     numSimulationRan += 1; 
    } 

    System.out.println(); 
    System.out.println("Average waiting time per customer: " + (double) averageWaitingTime/1000); 
    System.out.println("Average longest waiting time: " + (double) averageLongestWaitingTime/1000); 
    System.out.println("Average number of minutes: " + (double) averageSimulationTime/1000); 
    System.out.println("Longest waiting time: " + maxWaitingTime); 
    System.out.println("Average number of customers " + (double) averageNumServed/1000); 
    System.out.println("Number of times the simulation ran: " + numSimulationRan); 
} 

}

Ausgang:

A new customer arrives at time 5 
A new customer arrives at time 10 
A new customer arrives at time 11 
A new customer arrives at time 12 
A new customer arrives at time 25 
A new customer arrives at time 28 
A new customer arrives at time 31 
A new customer arrives at time 45 
A new customer arrives at time 48 
A new customer arrives at time 51 
A new customer arrives at time 59 
A new customer arrives at time 64 
A new customer arrives at time 68 
A new customer arrives at time 86 
A new customer arrives at time 100 
A new customer arrives at time 106 
A new customer arrives at time 108 
A new customer arrives at time 113 
A new customer arrives at time 115 
A new customer arrives at time 120 
A new customer arrives at time 124 
A new customer arrives at time 125 
A new customer arrives at time 126 
A new customer arrives at time 132 
A new customer arrives at time 137 
A new customer arrives at time 153 
A new customer arrives at time 156 
A new customer arrives at time 164 
A new customer arrives at time 201 
A new customer arrives at time 206 
A new customer arrives at time 208 
A new customer arrives at time 219 
A new customer arrives at time 226 
A new customer arrives at time 233 
A new customer arrives at time 234 
A new customer arrives at time 237 
A new customer arrives at time 242 
A new customer arrives at time 246 
A new customer arrives at time 247 
A new customer arrives at time 251 
A new customer arrives at time 262 
A new customer arrives at time 271 
A new customer arrives at time 276 
A new customer arrives at time 277 
A new customer arrives at time 282 
A new customer arrives at time 285 
A new customer arrives at time 287 
A new customer arrives at time 292 
A new customer arrives at time 296 
A new customer arrives at time 298 
A new customer arrives at time 318 
A new customer arrives at time 319 
A new customer arrives at time 327 
A new customer arrives at time 336 
A new customer arrives at time 337 
A new customer arrives at time 338 
A new customer arrives at time 346 
A new customer arrives at time 355 
A new customer arrives at time 356 
A new customer arrives at time 358 
A new customer arrives at time 362 
A new customer arrives at time 363 
A new customer arrives at time 366 
A new customer arrives at time 374 
A new customer arrives at time 379 
A new customer arrives at time 380 
A new customer arrives at time 384 
A new customer arrives at time 389 
A new customer arrives at time 400 
A new customer arrives at time 407 
A new customer arrives at time 416 
A new customer arrives at time 418 
A new customer arrives at time 424 
A new customer arrives at time 427 
A new customer arrives at time 433 
A new customer arrives at time 436 
A new customer arrives at time 437 
A new customer arrives at time 438 
A new customer arrives at time 446 
A new customer arrives at time 454 
A new customer arrives at time 466 
A new customer arrives at time 469 
A new customer arrives at time 471 

Average waiting time per customer: 1.0 
Average longest waiting time: 2.714 
Average number of minutes: 475.0 
Longest waiting time: 8 
Average number of customers 83.0 
Number of times the simulation ran: 1000 

Average waiting time per customer: 2.0 
Average longest waiting time: 2.714 
Average number of minutes: 950.0 
Longest waiting time: 8 
Average number of customers 166.0 
Number of times the simulation ran: 2000 

Average waiting time per customer: 3.0 
Average longest waiting time: 2.714 
Average number of minutes: 1425.0 
Longest waiting time: 8 
Average number of customers 249.0 
Number of times the simulation ran: 3000 

Answer 1

Es gibt ein Prinzip genannt Don't Repeat Yourself or DRY. Bevor der Begriff geprägt wurde, pflegten wir zu scherzen, dass Faulheit eine gute Eigenschaft eines Programmierers ist: Wenn du etwas zweimal machen musst, tust du es zu oft.

Vielleicht könnten Sie einige methods erklären, weil Ihr Programm den gleichen Code dreimal zu haben scheint.

Ironischerweise gibt es eine Sache, die Sie nur einmal tun: die Statistik Variablen initialisieren:

int numServed = 0; 
... 

Wenn Sie diesen Abschnitt kopieren und entfernen Sie die Typen (so liest es numServed = 0; usw.), und kopieren Sie dann, dass einmal mehr Es würde diese Variablen zurücksetzen. Kopieren-Einfügen-Code ist jedoch eine schlechte Praxis: Jetzt haben Sie 3 mal so viel Code zu pflegen.

Um dies zu beheben, können Sie Ihr Programm wie folgt strukturiert:

class QueueSimulation 
{ 
    public static void main(String[] args) { 
     for (int test = 0; test < 3; test ++) { 
      int numServed = 0; 
      .. 
      for (int i = 0; i < 1000; i++) { 
       ... 
      } 
      System.out.println(); 
      ....  
     } 
    } 
} 

Es gibt keinen doppelten Code, und es lokalisiert die Variablen, so dass sie für jede Simulation zurückgesetzt werden - die Ihr Problem behebt.

Dies ist nur ein Schritt in die richtige Richtung. Ein weiterer Schritt ist factor out Methoden bei abstraction levels, wie Top-Down and Bottom-Up design.
TLDR: Eine gute Faustregel ist zu jede Methode passen auf einer Seite des Textes.

In Ihrem Fall: Sie laufen die gleiche Simulation 3 Mal. Was die Details dieser Simulation sind, spielt für die Methode, die die Simulation dreimal ausführt, keine Rolle.

Hier ist eine andere mögliche Gliederung, wo wir die Variablen in Felder der QueueSimulation Klasse umgewandelt haben. Um sie zu initialisieren, instanziieren wir einfach eine neue QueueSimulation. Hier gehts:

class QueueSimulation 
{ 
    public static void main(String[] args) { 
     for (int test = 0; test < 3; test ++) { 
      QueueSimulation sim = new QueueSimulation(); 
      sim.simulate(); 
      sim.report(); 
     } 
    } 


    Queue<Customer> q = new LinkedList<Customer>(); 
    int numServed = 0; 
    ... 
    int totalProcessingTime = 0; 

    public void simulate() { 
     for (int i = 0; i < 1000) { 
      .... 
     } 
    } 

    public void report() { 
     System.out.println(.... 
     ...   
    } 
}