1

Prozeßorientierter Simulator mit Java

Stationen können in Java mit Objekten einer Klasse

modelliert werden, ebenso Entitäten. Entitäten sind

einfach Datenverbunde mit Attributen und

Zustandsvariablen. Die Klassen für Stationen enthalten

auch Prozeßroutinen, mit denen ihre Prozesse

modelliert werden.

2

Das natürliche Sprachkonstrukt für Prozeßroutinen

wären Koroutinen. Da solche in den meisten

Programmiersprachen nicht vorhanden sind, muss man nach

einem Ersatz suchen.

In Java bieten sich hier Threads an. Damit wird das

Simulationsprogramm ein Mehrprozessprogramm, und man

muß gegenseitige Störungen verhindern. Das geschieht,

indem gefährdete Programmteile wechselseitig

ausgeschlossen ausgeführt werden. Der Konstrukt in Java

dafür ist synchronized, allgemeiner gesprochen ein

Monitor.

3

Stationsklassen enthalten Konstanten, Variablen und

Datenverbunde für Attribute und Zustände, Threads und

Prozeduren für Prozeßroutinen und weitere Prozeduren

für die Modellbeschreibung, den Bericht, und für

Spurtritte.

 

Wenn eine Prozeßroutine das Ende eines Zeitintervalls

zu erwarten hat oder auf geplante Ereignisse warten

muß, wird sie mit einem Thread modelliert und heißt

dann „aktiv“.

Prozeßroutinen, die nur

auf Entitäten warten, können mit einfachen Prozeduren

gebildet werden; wir sprechen dann von passiven

Prozeßroutinen.

4

Muß ein Prozeßthread auf ein Ereignis warten, führt er

wait() aus. Ein anderer Prozeß kann ihn mit notify()

wieder wecken.

 

Der Simulationsalgorithmus wird von einem eigenen Thread ausgeführt. Er fährt immer dann fort, sobald alle Ereignisaktionen zu einem Zeitpunkt durchgeführt sind, d.h. entweder rechnen die Prozesse der Stationen, oder der Simulationsalgorithmus wird ausgeführt.

5

Prozeßverzögerung:

// Ein Prozess einer Station wartet einen Zeitraum Delta_t// der Simulationszeit ab: public synchronized void warte(double Delta_t){ S.plane_Ereignis(S.Uhr+Delta_t, (Ereignis)this, null); S.PSS_wird_inaktiv(); try{ wait(); // der Prozess schlaeft, bis der Simulator // in der Ereignisroutine notify() ausfuehrt } catch(InterruptedException ign){} }

// Prozeß wird geweckt:

public synchronized void Ereignisroutine(){ S.PSS_wird_aktiv(); notify(); }

6

// Prozeß wird geweckt:

public synchronized void Ereignisroutine(){

S.PSS_wird_aktiv();

notify();

}

Der Simulationsalgorithmus fährt immer dann fort, sobald alle Ereignisaktionen zu einem Zeitpunkt durchgeführt sind, d.h. entweder rechnen die Prozesse der Stationen, oder der Simulationsalgorithmus wird ausgeführt.

if (Anz_aktiver_PSSe > 0) {

try{ wait(); // der Simulator schlaeft, bis der letzte

// aktive Prozess notify() ausfuehrt

} catch(InterruptedException ign){};

// aktiv bedeutet hier: PSS bearbeitet gerade ein Ereignis

7

public synchronized void PSS_wird_aktiv() {

// aktiv bedeutet hier: PSS bearbeitet gerade ein Ereignis

Anz_aktiver_PSSe ++;

}

public synchronized void PSS_wird_inaktiv() {

Anz_aktiver_PSSe --;

if (Anz_aktiver_PSSe == 0) notify();

// kein Stations-PSS mehr aktiv,

// d.h. alle Vorgaenge zu diesem Zeitpunkt sind abgelaufen,

// der Simulator kann weitermachen

}

8

public class Station { // zum Erweitern

public String Stationsname;

// Umgebung

public Simulation S;

public Modell M;

public String Name(){return Stationsname;}

public void Eingang(Entitaet Kunde) {}

}

9

public class Modell { // zum Erweitern

public String Modellbeschreibung, Bericht;public int Spur;

public void beginne_Simulation(double t){}// Starte Stationen

// Plane Simulationshaltereignis // Lege Simulationshaltezeitpunkt fest // Statistische Zähler auf 0 gesetzt

public void Spurdaten(Ereignis E){} // fuer explizit modellierte Ereignisse public void setze_Simulation_fort(double t){} // Lege neuen Simulationshalt fest public void beende_Simulation() {} // Halte Station-Threads an public int Zaehlerstaende(statistischer_Zaehler[] z) {return 0;} // Verweis auf alle statistischen Zaehler public void setze_Zaehler_zurueck() {}}

10

public class poWSS_Modell extends Modell {

// Konstanten: // Zustaende des Bedieners: public final static int frei = 0, belegt = 1;

// Arten des Bedienungsbeginns: public final static int sofort = 1, spaeter = 0; // Zustand: public int N; // Anzahl der Kunden im Warteschlangensystem (WSS) public int B; // Bediener frei oder belegt // Attribute des Modells // Statistische Zaehler: public statistischer_Zaehler // integrierend: Kundenzahl, Wartende, Bedienerbelegung, // summierend: Wartezeiten, Sofortbedienungen;

11

// Experimentplanung:

public double Endzeitpunkt;

public int Zufallszahlen_Strom;

public Zufalls_Zahlen ZZahl;

public Simulation S;

// Stationsklassen:

class Quelle extends Station implements Runnable {}

// Modellaspekt: Poisson-Quelle

// Simulationsaspekt: Station mit Bedienprozess als Thread,

// Verzoegerer fuer Zwischenankuntszeiten

12

class WSS extends Station implements Runnable {// Modellaspekt: Warteschlangensystem// mit einem Bediener mit zwischen a und b gleichverteilter// Bediendauer und FIFO-Strategie// Simulationsaspekt: Station mit Bedienprozess als Thread,// Warteraum-Klasse, spontane Prozessroutine,// einem Eingang fuer Kunden, // Verzoegerer fuer Bedienzeiten

//-------------------------------------------------------------------- class FIFO_Warteraum {

// Hilfsvariable Entitaet K; //Zustand int Q; // Anzahl in der Warteschlange Liste Warteschlange = new Liste(); boolean Bediener_wartet_auf_Kunden = false;

13

public synchronized void Eingang(Entitaet Kunde) { // Passive PSS-Routine, // wechselseitig ausgeschlossen, von mehreren anderen PSSen benutzt // warten auf Kunden K = Kunde; K.Zwischenzeit = S.Uhr; // neuer Zustand Q++; Warteschlange.verlaengere(S.Uhr,null,K); // Statistik: Wartende.akkumuliere(+1); if (Bediener_wartet_auf_Kunden) { Sofortbedienungen.addiere(sofort); } else { Sofortbedienungen.addiere(spaeter); } // Spuraufzeichnung: if (Spur>0) Spurdaten1(); if (Bediener_wartet_auf_Kunden) { S.PSS_wird_aktiv(); notify(); // wecke Bediener } }

14

public synchronized Entitaet hole_Kunden() {// holt Kunden aus der WS, Teil der aktiven PSS-Routine if (Q == 0) { Bediener_wartet_auf_Kunden = true; S.PSS_wird_inaktiv(); try{ wait(); // dieser Prozess schlaeft, bis ein anderer PSS

notify() // ausfuehrt, nachdem er einen Kunden geschickt hat

} catch(InterruptedException ign){} } K = Warteschlange.Entitaet_am_Kopf()

// Neuer Zustand Q--; Bediener_wartet_auf_Kunden = false; Warteschlange.entferne_Kopf(); // Statistik Wartende.akkumuliere(-1);

Wartezeiten.addiere(S.Uhr - K.Zwischenzeit); // Spuraufzeichnung: if (Spur>0) Spurdaten2(); return K; }

15

// Fuer die Modellbeschreibung:

public String beschreibe_Station() {...} //

// Spurdatenerzeuger:

void Spurdaten1(){...}

void Spurdaten2(){...}

} // Ende Klasse FIFO_Warteraum

16

Weiter mit Klasse WSS:

public void Eingang(Entitaet Kunde) { WR.Eingang(Kunde); }

// Hilfsvariablen double Bediendauer; // Warteraum FIFO_Warteraum WR = new FIFO_Warteraum(); // Attribute double a,b; public Station Ziel; // Initialisierungen: WSS(String Name, double a, double b, Station Ziel, Simulation S, Modell M)

{...} // Verzoegerer fue die Bedeindauern Verzoegerung Bedienung;

17

public void run() {// Bedienprozess, Thread: // Hilfsvariable Kunde Entitaet K; do { K = WR.hole_Kunden(); // aus der Warteschlange; warten, wenn diese leer ist

Bediendauer = ZZahl.gleichverteilt(a,b); // Zustand B = belegt; //Statistik Bedienerbelegung.akkumuliere(+1); // Spur: if (Spur>0) Spurdaten(); // warten auf Bedienungsende: Bedienung.warte(Bediendauer); // Zustand B = frei; //Statistik Bedienerbelegung.akkumuliere(-1); // Kunde zur naechsten Sation: Ziel.Eingang(K); } while (true); }

18

// Spurdatenerzeuger:

void Spurdaten(){...}

// Fuer die Modellbeschreibung:

public String beschreibe_Station() {...}

// Fuer den Ergebnisbericht:

public String berichte() {...}

} // Ende der Klasse WSS

class Senke extends Station { ...}

// Modellaspekt: Senke

// Simulationsaspekt: Station, ein Prozess mit einer passiven

// Prozessroutine (Eingang), kein Thread

19

// Ereignisroutine, gibt es auch bei prozessorientierter Simulation:

class Simulationshaltereignis extends Ereignis {

public void Ereignisroutine(){

// Simulationshalt, aber die Simulation kann danach

// fortgesetzt werden, mit setze_fort(neue Endzeit);

// Bis zur aktuellen Uhrzeit akkumulieren:

Kundenzahl.akkumuliere(0);

Wartende.akkumuliere(0);

Bedienerbelegung.akkumuliere(0);

Bericht = ...

}

}

20

Weiter mit Klasse poWSS_Modell:

//Stationen mit ihren Prozessen:

Senke Loch; // Variable Typ Senke;

WSS MG1; // Variable Typ WSS

Thread Bedienprozess; // Variable fuer den Prozess des Bedieners

Quelle Ankuenfte; // Variable Typ Quelle

Thread Ankunftsprozess; // Variable fuer den Prozess der Quelle

// Simulationshaltereignis:

Simulationshaltereignis SimHalt;

21

// Konstruktor, initialisiert ein Modell: public poWSS_Modell(double lambda, double a, double b, int Stromnummer, int Spur0) { ZZahl = new Zufalls_Zahlen(Stromnummer); Zufallszahlen_Strom = Stromnummer; S = new Simulation(this,2); // muss vor den Stationen mit ihren Prozessen instantiert werden

// 2 ist die Anzahl der Stationsprozesse // Einrichten der Stationen und ihrer Prozesse: Loch = new Senke("Loch", S, this); MG1 = new WSS("MG1", a, b, Loch, S, this); Bedienprozess = new Thread( (Runnable)MG1); Ankuenfte = new Quelle("Ankuenfte", lambda, MG1, S, this); Ankunftsprozess = new Thread( (Runnable)Ankuenfte); Kundenzahl = new integrierender_Zaehler("Kundenzahl",S); Wartende = new integrierender_Zaehler("Wartende",S); Bedienerbelegung = new integrierender_Zaehler("Bedienerbelegung",S); Wartezeiten = new summierender_Zaehler("Wartezeiten"); Sofortbedienungen= new summierender_Zaehler("Sofortbedienungen"); Modellbeschreibung = ...}