Programmieren mit Harald R. Haberstroh

Schreiben Sie ein Programm, welches die Warteschlange an einer Kasse simuliert.
Es sollen in beliebigen Abständen Namen der Kunden eingegeben werden können, die sich an der Kasse anstellen.
Die Kasse bedient nun einen Kunden nach dem anderen. Die Bearbeitungsdauer soll zufällig aus einem Intervall von 5 bis 10 Sekunden gewählt werden. In regelmäßigen Abständen soll die Warteschlange bzw. die Anzahl der Kunden ausgegeben werden:

hp@L309:~/queue/bin> java kassa/Warteschlange
Marina Kathi Klaus Susi
es warten: Marina Kathi Klaus Susi
Tom es warten: Marina Kathi Klaus Susi
bediene Marina
Manues warten: Kathi Klaus Susi
Marina fertig
elaes warten: Kathi Klaus Susi
bediene Kathi

es warten: Klaus Susi Tom Manuela
es warten: Klaus Susi Tom Manuela
es warten: Klaus Susi Tom Manuela
es warten: Klaus Susi Tom Manuela
Kathi fertig
es warten: Klaus Susi Tom Manuela
bediene Klaus
es warten: Susi Tom Manuela
es warten: Susi Tom Manuela
es warten: Susi Tom Manuela
es warten: Susi Tom Manuela
Klaus fertig
es warten: Susi Tom Manuela
bediene Susi
es warten: Tom Manuela
es warten: Tom Manuela
es warten: Tom Manuela
es warten: Tom Manuela
es warten: Tom Manuela
es warten: Tom Manuela
es warten: Tom Manuela
es warten: Tom Manuela
es warten: Tom Manuela
Susi fertig
es warten: Tom Manuela
bediene Tom
es warten: Manuela
es warten: Manuela
es warten: Manuela
es warten: Manuela
es warten: Manuela
es warten: Manuela
es warten: Manuela
es warten: Manuela
Tom fertig
es warten: Manuela
bediene Manuela
Manuela fertig

Normalerweise würde man so etwas mit Threads programmieren. Es gibt aber auch eine andere Möglichkeit durch die Verwendung eines InputStreamReader. Ein InputStreamReader besitzt eine nicht blockierende Methode um abzufragen, ob Eingabe vorhanden ist: ready(). Zum Lesen kann dann trotzdem ein BufferedReader verwendet werden, der den InputStreamReader verwendet:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
...
InputStreamReader instream = new InputStreamReader(System.in);
BufferedReader in = new BufferedReader(instream);

Damit kann man den Eingabestrom pollen:

boolean eof = false;
while (!eof) {
  // poll
  if (instream.ready()) { // is there something to read?
    String zeile = in.readLine(); // yes, read it
    System.out.println("------- " + zeile);
    if (zeile.equalsIgnoreCase("quit")) {
      eof = true;
    }
  } else {
    // no, do the other work...
    Thread.sleep(500); // wait 500 ms
  }
}
in.close();

Warteschlange als Ringpuffer

Eine Warteschlange besitzt drei Operationen:

put(element) ein Element in die Warteschlange aufnehmen.
get() das erste Element entfernen.
isEmpty() prüft, ob die Schlange leer ist.

Werden Daten in dieses Array aufgenommen und wieder entnommen, so kommt man bald ans Ende des Arrays. Man muss also wieder von vorne beginnen. Daher kann man sich das Array als Ring vorstellen:

Man benötigt zwei Zeiger (Indices), einen putIndex für die Schreiboperation put() und einen getIndex für die Leseoperation get().
Der Leseindex (getIndex) muss immer hinter dem Schreibindex (putIndex) sein. Sind beide Indices gleich, so ist der Puffer entweder leer oder ganz voll. Um dies zu unterscheiden, könnte man einen Füllstand einführen (usedSize).

public class Queue {
  public static final int DEFAULTSIZE = 10;
  private int size; // size of ringbuffer/queue
  private int usedSize; // so many elements are in the ringbuffer
  private char[] ring; // the ringbuffer
  private int getIndex = 0;
  private int putIndex = 0;

  public void put(char elem) {
    usedSize++;
    ring[putIndex] = elem;
    putIndex = (putIndex + 1) % size;
  }

  public char get() {
    usedSize--;
    char ret = ring[getIndex];
    getIndex = (getIndex + 1) % size;
    return ret;
  }

  public Queue(int size) {
    this.size = size;
    ring = new char[size];
  }

  public Queue() {
    size = DEFAULTSIZE;
    ring = new char[size];
  }

  public boolean isEmpty() {
    return usedSize == 0;
  }

  public int getSize() {
    return size;
  }
}

Queue.java enthält dokumentierten Sourcecode (Achtung Package queue) inklusive Fehlerbehandlung (die man normalerweise mit Exceptions machen würde) für eine Schlange von char.

Labels: Aufgabe, Java, PR2

# Eingestellt von Harald R. Haberstroh @ 10:21