Real - Time Java Seminar Asynchrone Ereignisse und Asynchroner Kontrolltransfer in Real - Time Java Sönke Eilers

Überblick Asynchrone Ereignisse ( Async Events ) Behandlungsprozeduren für Asynchrone Ereignisse ( Async Event Handler ) Asynchroner Kontrolltransfer

Asynchrone Ereignisse - Problematik In Realzeit – Systemen treten häufig Ereignisse auf Ereignisse treten zu nicht vorhersehbaren Zeitpunkten und in unbekannten Frequenzen auf (asynchron) Innerhalb eines Prozesses oder außerhalb (anderer Prozess, OS) eines Prozesses

Asynchrone Ereignisse - Anwendungsgebiete Ein Prozess soll über einen Fehler in einem anderen Prozess informiert werden Innerhalb einer Software soll möglichst schnell und zu nicht vorhersehbaren Zeitpunkten der Betriebsmodus geändert werden ( z.B. ein sicheres Herunterfahren eines Systems im Fehlerfall ) Um Berechnungen planbar zu machen Der Benutzer möchte den Prozess unterbrechen

Asynchrone Ereignisse Behandlung von Ereignissen durch Threads ist zu langsam, weil dem Thread Resourcen zugewiesen werden müssen Es sind Mechanismen nötig, um schnell auf asynchrone Ereignisse zu reagieren Handler sind in RTSJ ebenso wie Threads planbar, jedoch sind mehrere Handler auf einen Thread angesetzt

Asynchrone Ereignisse - Ebenen

Asynchrone Ereignisse – Schnittstellen-Ebene Die Schnittstellen – Ebene stellt die Verbindung zwischen der Umgebung und der JVM her Die Umgebung kann sowohl ein Betriebssystem als auch Hardware sein Die JVM wird mittels der Schnittstellen – Ebene über externe Ereignisse ( Happenings ) informiert

Asynchrone Ereignisse – Asynchrones Ereignis Ebene Objekte der Klasse AsyncEvent werden mit Hilfe der bindTo Methode mit einem externen Ereignis verbunden: AsyncEvent aEvent = new AsyncEvent(); aEvent.bindTo(2); // 2 ist SIGINT Der Schnittstellen – Ebene wird so mitgeteilt, dass dieses externe Ereignis an das Objekt aEvent weitergeleitet wird Das AsyncEvent startet die mit dem Ereignis assoziierten Behandlungsprozeduren

Asynchrone Ereignisse – Behandlungsprozeduren- Ebene Behandlungsprozeduren sind Objekte der Klasse AsyncEventHandler AsyncEvent Objekte werden mit den Methoden addHandler und setHandler mit Behandlungsprozeduren verbunden removeHandler entfernt den jeweiligen Handler

Asynchrone Ereignisse

Asynchrone Ereignisse – Klasse AsyncEvent

Asynchrone Ereignisse 1.AsyncEvent event = new AsyncEvent(); 2.AsyncEventHandler handler = new AsyncEventHandler() 3.// weitere Anweisungen zum Instanzieren von handler 4.// … 5.event.bindTo(2); 6.event.addHandler( handler ); 7.event.fire(); 8.If ( event.handledBy( handler ) 9.{ 10. event.removeHandler( handler ); 11.} 12.event.unbindTo(2);

Asynchrone Ereignisse - Assoziation Ein Ereignis kann durch mehrere Behandlungsprozeduren behandelt werden Mehrere Ereignisse können von der gleichen Behandlungsprozedur behandelt werden – Handler weiß jedoch nicht, welches Ereignis ihn aufgerufen hat

Asynchrone Ereignisse – Behandlungsprozeduren- Ebene Wenn ein Ereignis auftritt, werden alle mit dem Ereignis verbundenen Behandlungsprozeduren gestartet Im AEH wird durch das Ereignis die run Methode ausgeführt, die für jedes Auftreten des Ereignis die Methode handleAsyncEvent aufruft

Asynchrone Ereignisse – Klasse AsyncEventHandler

AsyncEventHandler handler = new AsyncEventHandler(){ public void handleAsyncEvent(){ System.out.println(Im Handler!); } };

Asynchrone Ereignisse – Klasse AsyncEventHandler AsyncEventHandler handler = new AsyncEventHandler(){ public void handleAsyncEvent(){ int pending; do{ System.out.println(Im Handler!); } while ( (pending = getAndDecrementPendingFireCount()) > 0 ); } };

Asynchrone Ereignisse – Klasse AsyncEventHandler AsyncEventHandler handler = new AsyncEventHandler(){ public void handleAsyncEvent(){ int fireCount = getAndClearPendingFireCount(); System.out.println(Im Handler!); } }; Das Ereignis ist mehrmals aufgetreten, soll aber nur einmal behandelt werden

Asynchrone Ereignisse - Klassendiagramm AsyncEventHandler implementiert die beiden Interfaces java.lang.Runnable und java.lang.Schedulable BoundAsyncEventHandler erbt von AsyncEventHandler Objekte der Klasse AsyncEventHandler sind planbar

Asynchrone Ereignisse – Beispiel SigintHandler Behandlungsprozedur, die ein SIGINT (STRG-C) vom Terminal abfängt und mit einer Ausgabe auf dem Terminal reagiert

Asynchrone Ereignisse – Beispiel SigintHandler Klasse SigHandler erbt von AsyncEventHandler Methode handleAsyncEvent wird überschrieben

Asynchrone Ereignisse – Beispiel SigintHandler 1.class SigHandler extends AsyncEventHandler{ 2. public void handleAsyncEvent(){ 3. int pending; 4. do{ 5. System.out.println("Signal SIGINT wurde 6. empfangen!"); 7. } while ( ( pending = getAndDecrementPendingFireCount() ) > 1 ); 8. } 9.}

Asynchrone Ereignisse – Beispiel SigintHandler Die Klasse SigintHandler erbt von RealTimeThread

Asynchrone Ereignisse – Beispiel SigintHandler 1. import javax.realtime.*; 2. public class SigintHandler extends RealtimeThread 3. { 4. public static void main ( String [] args ) 5. { 6. SigintHandler siha = new SigintHandler(); 7. siha.start(); 8. try 9. { 10. Thread.sleep(1000); 11. } catch (Exception e){}; 12. } // Ende von main

Asynchrone Ereignisse – Beispiel SigintHandler 13. public void run() 14. { 15. MemoryArea immortal = ImmortalMemory.instance(); 16. AsyncEvent event = null; 17. AsyncEventHandler handler = null; 18. try{ 19. event = (AsyncEvent) immortal.newInstance(AsyncEvent.class); 20. handler = (AsyncEventHandler) immortal.newInstance(SigHandler.class); 21. } catch (InstantiationException e){ e.printStackTrace(); } 22. catch (IllegalAccessException e){ e.printStackTrace(); }

Asynchrone Ereignisse – Beispiel SigintHandler 23.// noch in run() 24. event.addHandler( handler ); 25. event.bindTo("2"); 26. System.out.println("SIGINT (STRG-C) wird ab jetzt behandelt!"); 27. try 28.{ 29. Thread.sleep( ); 30. } catch ( Exception e ){} 31. System.out.println("Handler wird wieder entfernt und Programm beendet"); 32. Event.removeHandler( handler ); 33. } // Ende von run() 34.} // Ende der Klasse SigintHandler

Asynchrone Ereignisse – Beispiel SigintHandler Beispielausgabe: SIGINT (STRG-C) wird ab jetzt behandelt! Signal SIGINT wurde empfangen! Handler wird wieder entfernt und Programm beendet

Threads vs. AEHs Threads warten und schlafen AEHs sind blockiert, oder werden ausgeführt Threads können lange laufen AEHs sollen meist nur wenig Code ausführen und beenden Threads müssen unter Umständen auf Resourcen warten AEHs sollen so bald wie möglich ausgeführt werden

Asynchrone Ereignisse - Implementierung von Asynchronous Event Handler Die Referenz – Implementierung von RTSJ erzeugt für jeden AEH einen Thread, wenn ein Ereignis aufgetreten ist Schlechte Leistung der Implementierung Verbesserung: für jeden AEH wird ein Thread erzeugt

Asynchrone Ereignisse – Bound Asynchronous Event Handler Die Klasse BoundAsyncEventHandler erbt von der Klasse AsyncEventHandler Ein BoundAsyncEventHandler ist dauernd an einen eigenen Thread gebunden und hat ein besseres Zeitverhalten als ein AEH

Asynchrone Ereignisse – Programmieren mit AEHs Verwendung der AEHs zu andern Zwecken als auf externe Ereignisse zu reagieren: –Jeglicher Code, der die fire Methode eines Ereignisses aufrufen kann –Zeitliche Ereignisse ( Timer ) –Fehler

Asynchrone Ereignisse – Timer Die Timer Objekte werden mit einem Handler verbunden Der OneShotTimer führt seinen Handler zu einem bestimmten Zeitpunkt aus Der PeriodicTimer führt seinen Handler periodisch aus

Asynchrone Ereignisse - OneShotTimer OneShotTimer timer = new OneShotTimer( new RelativeTime( 10000, 0 ), // 10 Sekunden handler); timer.start(); 10 Sekunden nach Start des Timers wird der für timer eingetragene Handler ausgeführt.

Asynchrone Ereignisse - PeriodicTimer PeriodicTimer timer = new PeriodicTimer( null, // wird sofort gestartet new RelativeTime(2000, 0), // alle 2 Sek. handler); timer.start(); … timer.disable(); … timer.enable(); //… timer.stop(); Der PeriodicTimer löst nach dem Aufruf seiner start Methode alle 2 Sekunden seinen Handler aus.

Asynchrone Ereignisse – Fehlerbehandlung mit AEs Im Fehlerfall kann die fire Methode eines Asynchronen Ereignisses dazu genutzt werden, dass –die Fehlerbehandlung asynchron zu dem Code stattfindet, der den Fehler ausgelöst hat –verschiedene Threads einen Handler für ein Ereignis registrieren können

Asynchrone Ereignisse – weitere Nutzung Anstelle eines RealTime - Threads Als ein allgemeiner Mechanismus für Mitteilungen innerhalb eines Programms (um AWT events zu ersetzen )

Asynchroner Kontrolltransfer Man unterscheidet bei der Behandlung von asynchronen Meldungen zwischen –dem wiederaufnehmenden Modell ( Event Handling ) –dem terminierenden Modell (ATC)

Asynchroner Kontrolltransfer – wiederaufnehmendes Modell (AEH) Das wiederaufnehmende Modell wird auch Ereignisbehandlung genannt Ein Prozess wird durch ein Ereignis unterbrochen, behandelt dieses und fährt an der Stelle weiter, an der es unterbrochen wurde Die Behandlung kann auch nebenläufig stattfinden

Asynchroner Kontrolltransfer - AEH

Asynchroner Kontrolltransfer – terminierendes Modell (ATC) Asynchroner Kontrolltransfer: Jeder Prozess hat einen bestimmten Bereich, innerhalb dessen er durch eine asynchrone Nachricht unterbrochen werden kann Dies kann den Thread beenden oder weitere Aktionen im Thread auslösen

Asynchroner Kontrolltransfer In früheren Implementierungen von Threads in Java gab es die Methoden resume, suspend und stop Diese sind inzwischen veraltet ( deprecated ) Es werden heute nur noch die Methoden interrupt und destroy als Mechanismen für ATC in Java genutzt

Asynchroner Kontrolltransfer Der asynchrone Kontrolltransfer ist in die Ausnahmebehandlung integriert worden ATC wird in RTSJ durch das werfen einer AIE Ausnahme erreicht

Asynchroner Kontrolltransfer Der Bereich, in dem der Thread unterbrochen werden darf, muss festgelegt werden: void tuWas() throws AsynchronouslyInterruptedException {} Methoden die keine AIE werfen sind daher nicht von Interrupts betroffen Somit ist auch älterer, ererbter Code der nichts von RTSJ weiß sicher vor Überraschungen

Asynchroner Kontrolltransfer – ATC in RTSJ Es gibt drei Mechanismen in RTSJ, um eine AIE auszulösen: –Die interrupt Methode auf einen RealtimeThread aufrufen –Die fire Methode auf einer AIE aufrufen –Ein Timed Objekt wirft eine AIE auf eine run Methode

Asynchroner Kontrolltransfer Erzeugt man in einem Thread mit Hilfe von rt.interrupt() eine Ausnahme in dem RealtimeThread rt, so spricht man von einer generic AIE, die geworfen wird Dieser Mechanismus ist dazu gedacht, den jeweiligen Thread zu beenden, die AIE kann aber auch innerhalb einer catch Anweisung behandelt werden ( hierfür ist AIE.fire() besser geeignet) Die Ausnahme ist nicht mit der doInterruptable Methode verbunden

Asynchroner Kontrolltransfer Wenn man einen Thread mit rt.interrupt() unterbricht, ist die Reaktion abhängig von dem Zustand in dem sich der Thread befindet Ist der Thread in einer Methode oder an einer Stelle im Thread, die keine AIEs behandeln kann, wird abgewartet, bis das Programm eine Methode erreicht in der eine AIE geworfen werden kann public void nichtUnterbrechbar { … } … // nicht unterbrechbar im RT-Thread public void unterbrechbar throws AIE {…}

Asynchroner Kontrolltransfer Innerhalb des try Blocks wird die Ausführung unterbrochen und es geht beim catch weiter Wird keine AIE gefangen, wird die AIE in der aufrufenden Methode geworfen public void unterbrechbar() throws AIE{ try{ … } catch (AIE aie){} }

Asynchroner Kontrolltransfer Wird die AIE außerhalb des try Blocks geworfen, wird die Methode terminiert und die wird AIE in der aufrufenden Methode geworfen public void unterbrechbar() throws AIE{ … // sollte die AIE hier geworfen werden try{ … } catch (AIE aie){} }

Asynchroner Kontrolltransfer Falls der Thread durch ein wait, sleep oder join blockiert ist, wird der Thread neu geplant und die AIE wird geworfen public void unterbrechbar() throws AIE{ Thread.sleep( 2000 ); }

Asynchroner Kontrolltransfer Falls der Thread in einer nicht zu unterbrechenden Methode blockiert ist, wird der Thread neu geplant und die AIE als abwartend markiert public void nichtUnterbrechbar(){ Thread.sleep( 2000 ); }

Asynchroner Kontrolltransfer Die fire Methode wird auf einem AIE Objekt aufgerufen Zusammen mit der doInterruptable Methode des AIE Objekts kann man so einen Asynchronen Interrupt an eine bestimmte Methode eines RT-Threads schicken Die doInterruptible Methode eines AIE Objekts hat als Argument ein Objekt einer Klasse, die das Interruptible interface implementiert

Asynchroner Kontrolltransfer In der run Methode steht der Code der ausgeführt werden soll In der interruptAction Methode der Code, der im Fall eines Interrupts ausgeführt werden soll

Asynchroner Kontrolltransfer rt.this.aie = new AIE(); rt.this.aie.doInterruptible( new Interruptible(){ public void interruptAction( AIE aie ){ // wird bei Interrupt ausgeführt } public void run( AIE aie) throws AIE{ // wird ansonsten ausgeführt } }); // Ende von doInterruptible

Asynchroner Kontrolltransfer Ein Timed Objekt wirft zu einem gegebenen Zeitpunkt eine AIE in der run Methode seiner doInterruptible Methode Timed timed = new Timed( new RelativeTime(1000,0)); Timed.doInterruptible( new Interruptible() {…});

Vorführung