Threads Echtzeitsimulation mit Java

[Nico_G]

Hallo an alle,

ich schreibe zur Zeit an meiner Masterarbeit und will eine kleine Echtzeitsimulation erstellen. Bei dieser habe ich Probleme die verschiedenen Threads zu synchronisieren. Ich versuche mal mein Problem möglichst simpel darzustellen:

Ich habe ein Objekt Anlage von welchem ich 100 Instanzen erstelle. Jede Anlage verfügt über eine Fehlerzeitreihe (ein Jahr), dargestellt durch ein zweidimensionales Array (Tag, Stunde). Kein Fehler wird durch 0 und ein Fehler durch die Zahl 1 dargestellt. Weiter verfügt jede Anlage über einen Thread in welchem das Array durchlaufen wird und bei einem Fehler das dazugehörige Fehlerobjekt in einen gemeinsamen Stapel schreibt.

Dann gibt es ein Objekt Reperaturcrew welches in einem eigenen Thread den Stapel überwacht. Findet es in dem Stapel einen neuen Fehler, rückt die Crew zur Anlage aus und repariert diese. Ist die Reperatur erfolgreich abgeschlossen steht die Crew wieder zur Verfügung und kann den nächsten Fehler beheben, bzw. auf einen Warten.

Das ist jetzt eine sehr sehr vereinfachte darstellung dessen was das Programm machen soll, aber ich glaube im Kern verständlich. Falls nicht: Löchert mich!

Meine Frage ist jetzt wie ich es schaffe die Threads sinnvoll zu synchronisieren. Ich möchte gerne das jede Anlage erst einmeal Stunde 1 an Tag 1 anschaut ob ein Fehler vorliegt. Dann soll die Reperaturcrew schauen ob Fehler im Stapel vorhanden sind. Dann sind wieder die Anlagen an der Reihe zu schauen: Stunde 2 Tag 1 usw.

Momentan passiert es, dass z.B Anlage 72 einen Fehler an Tag 2 Stunde 24 in den Stapel schreibt und danach Anlage 12 einen Fehler welcher an Tag 1 Stunde 2. Der zweite Fehler hätte also vor den ersten Fehler in den Stapel geschrieben werden müssen.

Wenn ich einen sleep(1) in die Threads schreibe bekomme ich zwar das gewünschte Ergebnis, aber die Laufzeit ist dann halt total fürn Ar...... ;(

Im folgenden noch kurze (vereinfachte) Codebeispiele

Der Thread der Anlagen

public void run(){
			for(int j=0;j<365;j++){
				for(int k=0;k<24;k++){
					
					if(fehlerreihe[j][k]==1){list.add(new Fehler(this.id,i,j,k,1));
					}
					
					try {
						sleep(0);                //wenn ich hier 1 einsetzt funktionier es wunderbar
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
		list.fertig=false;
	}

Hier der Thread der Reparaturcrew

public void run(){
			while(list.fertig){
				
				try {
					sleep(0);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				if(fehlerstack.list.size()>0){
                                        starteReparatur(list.get(0));
                                        list.remove(0);
				}
			}
		}

Vielleicht hat ja einer von Euch eine gute Idee..

Liebe Grüße

Nico

 

[Flown]

Also was mir jetzt spontan dazu einfällt, ist das am Ende jeden Tages alle Threads joinst(Garantiert dir trotzdem nicht die richtige Reihenfolge, aber zumindest tageweise). Oder sonst das du den Stapel an "Fehlern" sortierst.

 

[diggaa1984]

das problem bei der geschichte ist ja, dass du erwartest das alle Threads synchron laufen und dadurch eine zeitliche Reihenfolge der Meldungen eingehalten wird. Du hast allerdings gar keinen Einfluss darauf, welcher Thread wie lange arbeitet, bevor ein anderer rankommt, daher auch die falsche Reihenfolge der Meldungen. Ist es denn eine Vorgabe, dass die Anlagen als Threads selbst die Fehler melden, kann es nicht eine übergeordnete Instanz geben, die alle Anlagen überprüft? Wäre doch bestimmt auch aus industrieller Sicht nicht so falsch, oder? Etwas das Sensoren an den Anlage abfragt, und je nach Wert den Fehler kommuniziert. Dieses Etwas kann dann als einzelner Thread die Meldungen erzeugen.

 

[Nico_G]

das problem bei der geschichte ist ja, dass du erwartest das alle Threads synchron laufen und dadurch eine zeitliche Reihenfolge der Meldungen eingehalten wird. Du hast allerdings gar keinen Einfluss darauf, welcher Thread wie lange arbeitet, bevor ein anderer rankommt, daher auch die falsche Reihenfolge der Meldungen. Ist es denn eine Vorgabe, dass die Anlagen als Threads selbst die Fehler melden, kann es nicht eine übergeordnete Instanz geben, die alle Anlagen überprüft? Wäre doch bestimmt auch aus industrieller Sicht nicht so falsch, oder? Etwas das Sensoren an den Anlage abfragt, und je nach Wert den Fehler kommuniziert. Dieses Etwas kann dann als einzelner Thread die Meldungen erzeugen.

Hey, das ist gar keine schlechte Idee. damit werde ich mich gerad mal bescheftigen. Vielen Dank schon mal =)

 

[Nico_G]

Habe gerade mit meinem Betreuer geredet und dem ist das ganze Prozedere mit den Threads viel zu heikel. Bzw. es tauchen dadurch viel zu viele technische Schwierigkeiten auf.

Anstelle einer Echtzeitsimulation wird es jetzt eine Zeitreihensimulation werden.

Trotzdem vielen Dank für die Antworten, gerade die zweite ist glaube ich eine gute Lösung.

Greez

Nico

 

[ThreadPool]

Anstelle einer Echtzeitsimulation wird es jetzt eine Zeitreihensimulation werden.
[...]

Meinst du mit Zeitreihen Werte und deren Entwicklung über die Zeit? Das kann mathematisch wesentlich anspruchsvoller werden, je nach verwendetem statistischen Modell etc.

Davon abgesehen suche ich in deiner ursprünglichen Beschreibung noch nach der "Echtzeit"-Komponente. Da du mit Tagen/Monaten/Jahren hantierst müsste deine Simulation äquivalent lange laufen. Da das nicht so ist und du auch diskrete Zeitpunkte verwendest ist es in den Bereich diskrete ereignisorientierte Simulation einzuordnen. Die kann man verschiedenartig durchführen, der Versuch von dir z.B. prozessorientiert mit Threads. Es geht aber auch ohne Threads, was dann grob gesagt an eine riesige Zustandsmaschine erinnert. Kennst du dich mit dem Bereich - Simulation - überhaupt aus?

 

[Gast2]

Ich muss mal noch meinen Senf dazugeben, denn mich verwirrt der Begriff Echtzeit hier doch sehr. Wir arbeiten mit Echtzeitsystemen und naja ... zumindest Standard Java ist da gänzlich ungeeignet. Desweiteren haben Threads nichts mit Echtzeit zu tun!

Was die Probleme mit Threads betrifft gibts da viele und mich wundert auch immer, wieso hier soviel mit Threads gemacht wird.

Wir benötigen meistens keine Threads in unserer Software, da wir falls möglich immer mit Event Driven Frameworks arbeiten. Letztlich ist das meistens schneller und immer sicherer, da die bekannten Concurrency und Deadlock Probleme entfallen.

 

[Nico_G]

Meinst du mit Zeitreihen Werte und deren Entwicklung über die Zeit? Das kann mathematisch wesentlich anspruchsvoller werden, je nach verwendetem statistischen Modell etc.

Davon abgesehen suche ich in deiner ursprünglichen Beschreibung noch nach der "Echtzeit"-Komponente. Da du mit Tagen/Monaten/Jahren hantierst müsste deine Simulation äquivalent lange laufen. Da das nicht so ist und du auch diskrete Zeitpunkte verwendest ist es in den Bereich diskrete ereignisorientierte Simulation einzuordnen. Die kann man verschiedenartig durchführen, der Versuch von dir z.B. prozessorientiert mit Threads. Es geht aber auch ohne Threads, was dann grob gesagt an eine riesige Zustandsmaschine erinnert. Kennst du dich mit dem Bereich - Simulation - überhaupt aus?

Mit Echtzeit meinte ich eher das ich die Zeit einstellen kann. Also das eine Stunde wirklich eine Stunde ist, oder eben nur 1 Millisekunde. Wie ich es halt einstelle. Das ist aber jetzt halt laut meinem Prof. nicht nötig. Es wird jetzt eher die von Dir beschriebene "riesige Zustandsmaschine".

Mit Simulationen, gerade in Java, kenne ich mich noch nicht so wirklich gut aus. Gerade erst angefangen mit dem Thema und noch nicht einmal 100% ausformuliert. Wenn Du da gute Literatur oder Quellen zum Einstieg wüsstest wäre ich für einen Hinweis dankbar.

Nico

 

[Nico_G]

Ich muss mal noch meinen Senf dazugeben, denn mich verwirrt der Begriff Echtzeit hier doch sehr. Wir arbeiten mit Echtzeitsystemen und naja ... zumindest Standard Java ist da gänzlich ungeeignet. Desweiteren haben Threads nichts mit Echtzeit zu tun!

Was die Probleme mit Threads betrifft gibts da viele und mich wundert auch immer, wieso hier soviel mit Threads gemacht wird.

Wir benötigen meistens keine Threads in unserer Software, da wir falls möglich immer mit Event Driven Frameworks arbeiten. Letztlich ist das meistens schneller und immer sicherer, da die bekannten Concurrency und Deadlock Probleme entfallen.

Das schaue ich mir mal an

 

[Skrodde]

Wenn Du da gute Literatur oder Quellen zum Einstieg wüsstest wäre ich für einen Hinweis dankbar.

Schau dir mal diese Folien hier an. Es ist zwar etwas her, dass ich die Vorlesung gehört habe, aber meiner Meinung nach beschreiben Folien und Skript die unterscheidlichen Prinzipien von Simulation ganz gut.

 

[Deception]

Hey,
Wir haben in der Uni eine Vorlesung grade dazu gehabt.
Da wurde das Framework DesmoJ eingeführt, welches an der Uni Hamburg entwickelt wird.
Wenn du sowas benutzen darfst, lohnt es sich, sich das mal anzuschauen, damit sparst du dir die thread Verwaltung. In der Masterarbeit kannst du ja trotzdem darüber schreiben wie das Framework das löst. Dazu wirst du sicher etwas finden.
Beste Grüße,
Jens

EDIT: Der Prof. der die Vorlesung liest hat auch ein Buch über Simulationen geschrieben
The Java Simulation Handbook: Simulating Discrete Event Systems with UML and Java

 

[Nico_G]

Hey, vielen Dank für die Antwort,

DESMO-J hört sich ganz gut an und ich werde mir das mal näher anschauen. Für diejenigen die es interessiert, ich habe ebenfalls ein ganz annehmbares Java-Toolkit für diskrete Simulationen gefunden.

MASON, zu finden unter

MASON Multiagent Simulation Toolkit

Nico