Real time java seminar asynchrone ereignisse und asynchroner kontrolltransfer in real time java
Download
1 / 47

Sönke Eilers - PowerPoint PPT Presentation


  • 94 Views
  • Uploaded on

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.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Sönke Eilers' - tevy


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Real time java seminar asynchrone ereignisse und asynchroner kontrolltransfer in real time java

Real - Time Java SeminarAsynchrone Ereignisse und AsynchronerKontrolltransfer in Real - Time Java

Sönke Eilers


Berblick
Überblick

  • Asynchrone Ereignisse ( Async Events )

  • Behandlungsprozeduren für Asynchrone Ereignisse ( Async Event Handler )

  • Asynchroner Kontrolltransfer


Asynchrone ereignisse problematik
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
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
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 schnittstellen ebene
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
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
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 ereignisse2
Asynchrone Ereignisse

  • AsyncEvent event = new AsyncEvent();

  • AsyncEventHandler handler = new AsyncEventHandler()

  • // weitere Anweisungen zum Instanzieren von handler

  • // …

  • event.bindTo(“2“);

  • event.addHandler( handler );

  • event.fire();

  • If ( event.handledBy( handler )

  • {

  • event.removeHandler( handler );

  • }

  • event.unbindTo(„2“);


Asynchrone ereignisse assoziation
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 ebene1
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 asynceventhandler1
Asynchrone Ereignisse – Klasse AsyncEventHandler

AsyncEventHandler handler = new AsyncEventHandler(){

public void handleAsyncEvent(){

System.out.println(“Im Handler!“);

}

};


Asynchrone ereignisse klasse asynceventhandler2
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 asynceventhandler3
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
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 implementierung von asynchronous event handler
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
Asynchrone Ereignisse – Bound Asynchronous Event Handler 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
Asynchrone Ereignisse – Programmieren mit AEHs Event Handler

  • 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
Asynchrone Ereignisse – Timer Event Handler

  • 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
Asynchrone Ereignisse - OneShotTimer Event Handler

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
Asynchrone Ereignisse - PeriodicTimer Event Handler

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
Asynchrone Ereignisse – Fehlerbehandlung mit AEs Event Handler

  • 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
Asynchrone Ereignisse – weitere Nutzung Event Handler

  • Anstelle eines RealTime - Threads

  • Als ein allgemeiner Mechanismus für Mitteilungen innerhalb eines Programms (um AWT events zu ersetzen )


Asynchroner kontrolltransfer
Asynchroner Kontrolltransfer Event Handler

  • Man unterscheidet bei der Behandlung von asynchronen Meldungen zwischen

    • dem wiederaufnehmenden Modell ( Event Handling )

    • dem terminierenden Modell (ATC)


Asynchroner kontrolltransfer wiederaufnehmendes modell aeh
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 terminierendes modell atc
Asynchroner Kontrolltransfer – terminierendes Modell (ATC) (AEH)

  • 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 kontrolltransfer1
Asynchroner Kontrolltransfer (AEH)

  • 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 kontrolltransfer2
Asynchroner Kontrolltransfer (AEH)

  • Der asynchrone Kontrolltransfer ist in die Ausnahmebehandlung integriert worden

  • ATC wird in RTSJ durch das werfen einer AIE Ausnahme erreicht


Asynchroner kontrolltransfer3
Asynchroner Kontrolltransfer (AEH)

  • 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
Asynchroner Kontrolltransfer – ATC in RTSJ (AEH)

  • 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 kontrolltransfer4
Asynchroner Kontrolltransfer (AEH)

  • Erzeugt man in einem Thread mit Hilfe von rt.interrupt() eine Ausnahme in dem RealtimeThreadrt, 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 kontrolltransfer5
Asynchroner Kontrolltransfer (AEH)

  • 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 kontrolltransfer6
Asynchroner Kontrolltransfer (AEH)

  • 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 kontrolltransfer7
Asynchroner Kontrolltransfer (AEH)

  • 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 kontrolltransfer8
Asynchroner Kontrolltransfer (AEH)

  • 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 kontrolltransfer9
Asynchroner Kontrolltransfer (AEH)

  • 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 kontrolltransfer10
Asynchroner Kontrolltransfer (AEH)

  • 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 kontrolltransfer11
Asynchroner Kontrolltransfer (AEH)

  • 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 kontrolltransfer12
Asynchroner Kontrolltransfer (AEH)

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 kontrolltransfer13
Asynchroner Kontrolltransfer (AEH)

  • 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() {…});



ad