Entwicklung von Echtzeitanwendungen für die Java-Plattform

AS-SYSTEME Unternehmensberatung
Inhouse

3.101 
zzgl. MwSt.
Möchten Sie den Bildungsanbieter lieber direkt anrufen?
711 9... Mehr ansehen
Vergleichen Sie diesen Kurs mit ähnlichen Kursen
Mehr ansehen

Wichtige informationen

  • Seminar
  • Anfänger
  • Inhouse
  • Dauer:
    5 Tage
Beschreibung

Dieser Kurs vermittelt folgende Kenntnisse und Fähigkeiten: - Steuern von durch den Bereinigungsmechanismus verursachten Synchronisationsfehlern (Jitter) bei der Threadfreigabe. - Erstellen von RealtimeThread-Objekten und Steuern des Threadverhaltens mithilfe von SchedulingParameters und PeriodicParameters. - Steuern des gleichzeitigen Zugriffs auf Ressourcen und Beschreiben ..
Gerichtet an: Dieser Kurs richtet sich an Programmierer, Entwickler und Softwarearchitekten, die an der Entwicklung von Echtzeitsystemen unter Verwendung der Programmiersprache Java mit den RTSJ-Erweiterungen beteiligt sind. Teilnehmer müssen die Programmiersprache Java bis Version 1.4 beherrschen und schon Kenntnisse des Konzepts der Echtzeitprogrammierung haben. Umfassende Vorkenntnisse sind jedoch ...

Wichtige informationen

Häufig gestellte Fragen

· Voraussetzungen

Um diesen Kurs erfolgreich absolvieren zu können, sollten Sie über folgende Vorkenntnisse verfügen: - Entwerfen, Schreiben und Debuggen von Programmen mit Java 1.4. - Verwenden interner Klassen, einschließlich anonymer interner Klassen. - Verwenden der Thread-Funktionen von Java 1.4.

Themenkreis

Trainingsziel

Dieser Kurs vermittelt folgende Kenntnisse und Fähigkeiten:

  • Steuern von durch den Bereinigungsmechanismus verursachten Synchronisationsfehlern (Jitter) bei der Threadfreigabe.


  • Erstellen von RealtimeThread-Objekten und Steuern des Threadverhaltens mithilfe von SchedulingParameters und PeriodicParameters.


  • Steuern des gleichzeitigen Zugriffs auf Ressourcen und Beschreiben des Prioritätsumkehrungs- und Prioritätsvererbungsalgorithmus.


  • Kenntnis der Einschränkungen, die bei der Verwendung von Objekten in Nicht-Heap-Speicher gelten, und der Probleme, die bei der Verwendung von Bibliotheks-APIs in Nicht-Heap-Speicher auftreten können.


  • Bereitstellen von zeitlich abgestimmtem (timed) und asynchronem Verhalten mithilfe von AsyncEvent-, OneShotTimer-, PeriodicTimer- und AsyncEventHandler-Objekten.


  • Steuern des Einstellens asynchroner Ereignisse in Warteschlangen zum Begrenzen der Auswirkungen von spezifikationsverletzenden (out-of-spec) Ereignissen und Handlern in anderen Bereichen des Systems.


  • Asynchrones Unterbrechen von Threads und Steuern ihres Verhaltens unter diesen Bedingungen.


  • Verwenden von Portalen für den Zugriff auf Speicher mit Geltungsbereich (scoped memory).


  • Beschreiben und geeignetes Verwenden der run-Schleife mit Geltungsbereich, von eingekapselten Methoden, Abgaben (handoff), zeitlich abgestimmten Algorithmen, Objekten mit mehrfachem Geltungsbereich und Keil-Thread-Mustern (wedge thread).


  • Verwenden von Überlauf-Handlern (overrun) zum Begrenzen der Auswirkungen von spezifikationsverletzenden (out-of-spec) Threads in anderen Bereichen eines Systems.


Teilnehmerkreis

Dieser Kurs richtet sich an Programmierer, Entwickler und Softwarearchitekten, die an der Entwicklung von Echtzeitsystemen unter Verwendung der Programmiersprache Java mit den RTSJ-Erweiterungen beteiligt sind. Teilnehmer müssen die Programmiersprache Java bis Version 1.4 beherrschen und schon Kenntnisse des Konzepts der Echtzeitprogrammierung haben. Umfassende Vorkenntnisse sind jedoch nicht erforderlich.

Voraussetzungen

Um diesen Kurs erfolgreich absolvieren zu können, sollten Sie über folgende Vorkenntnisse verfügen:

  • Entwerfen, Schreiben und Debuggen von Programmen mit Java 1.4.


  • Verwenden interner Klassen, einschließlich anonymer interner Klassen.


  • Verwenden der Thread-Funktionen von Java 1.4.


Im Vorfeld

SL-275-SE6: Java Programmierung

Überblick über den Inhalt des Trainings

Der Kurs "Entwicklung von Echtzeitanwendungen für die Java-Plattform"

vermittelt den Teilnehmern die wesentlichen Fähigkeiten, die

erforderlich sind, um mithilfe der Echtzeitfunktionen der

Echtzeitspezifikation für Java (Real-Time Specification for Java, RTSJ)

Echtzeitanwendungen zu erstellen.

Einführung in die Echtzeitprogrammierung und in das Sun Java Real-Time System

  • Beschreiben der Echtzeitprogrammierung, der RTSJ und des Java Real-Time System.
  • Darstellen der Beziehungen zwischen Eingabe/Ausgabe (E/A), Ressourcenkonkurrenz, Bereinigungsmechanismus und Echtzeitsystemen.
  • Darstellen der durch die RTSJ bereitgestellten Speichertypen.
  • Beschreiben von grundlegenden Echtzeitarchitekturen.
  • Erstellen eines periodischen Echtzeitthreads.
  • Messen von Latency und Jitter eines periodischen Echtzeitthreads.


Interagieren mit der wirklichen Welt

  • Entwerfen von Objekten, die Zugriff auf Geräte gewähren.
  • Entwerfen von Objekten zur Verwendung in einem Echtzeitsystem.
  • Beschreiben von Aktuatoren und Sensoren.
  • Beschreiben von Möglichkeiten zum Anschließen von Hardware an Computer.
  • Darstellen der Verwendung von Raw- oder physikalischem Speicher.
  • Auswählen der geeigneten Methoden zur Behandlung externer Ereignisse.


Einrichten des Zeitrahmen-Managements

  • Ermitteln von Zeiteinschränkungen, die sich auf Aufgaben auswirken.
  • Ermitteln einer Basishäufigkeit für einen Zeitrahmen.
  • Implementieren eines Zeitrahmen-Managements.
  • Ermitteln und Kontrollieren von Frame-Kosten.
  • Beschreiben der Vorteile und Kosten der Zeitrahmenarchitektur.


Anwenden des PatternModule der run-Schleife mit Geltungsbereich.

  • Beschreiben der Auswirkungen auf den Bereinigungsmechanismus auf Echtzeitreaktionen.
  • Beschreiben, wie dauerhafte (immortal) Speicherbereiche und

    Speicherbereiche mit Geltungsbereich Effekte des

    Bereinigungsmechanismus verhindern können und wie Objekte in diesen

    Bereichen wiederhergestellt werden.
  • Beschreiben der Regeln für Speicher mit Geltungsbereich.
  • Erkennen vorhersagbarer Probleme mit NHRT-Threads.
  • Konfigurieren und Verwenden der Kompilierung zur Initialisierungszeit.
  • Beschreiben und Implementieren des Musters der run-Schleife mit Geltungsbereich (scoped run-loop).


Einführung in das ereignisgesteuerte ArchitectureModule

  • Beschreiben der ereignisgesteuerten Architektur.
  • Auflisten der Vorteile und Nachteile der ereignisgesteuerten Architektur.
  • Beschreiben, wie eine Einzel-CPU zeitlich geplant wird, wenn mehrere Threads mit unterschiedlichen Prioritäten ausführbar sind.
  • Beschreiben des Echtzeitobjektdesigns.
  • Entwerfen von Soundobjekten für ein Echtzeitsystem.
  • Zeitplanung und Dispatch in der RTSJ.
  • Schreiben von Code für aktive Komponenten in RTSJ.
  • Hinzufügen von Ereignissen zur Simulation.


Datensynchronisierung für gleichzeitige Aufgaben

  • Entwurf für die Datensynchronisierung.
  • Implementieren der Datensynchronisierung mithilfe des synchronized-Schlüsselworts.
  • Erkennen kritischer Abschnitte und Schützen dieser Abschnitte mit synchronisierten Blöcken.
  • Beschreiben der Techniken für die Prioritätsumkehrung und die Vermeidung der Prioritätsumkehrung.
  • Beschreiben der Java SE 5.0-Concurrency-Dienstprogramme (Nebenläufigkeit).
  • Beschreiben der Vergaberichtlinien für mehrere gemeinsam genutzte Ressourcen.


Behandlung asynchroner Ereignisse

  • Beschreiben der Behandlung asynchroner Ereignisse.
  • Beschreiben von asynchronen Ereignis-Handlern und Echtzeitthreads.
  • Schreiben von Code zur Verarbeitung eines POSIX-Signals.
  • Erstellen von anwendungsdefinierten Ereignissen.
  • Schreiben von Code zum programmgesteuerten Ausgeben eines Ereignisses.
  • Beschreiben aperiodischer Ereignisse und Schreiben von Code zum Steuern des Überlaufverhaltens der Ankunftszeit-Warteschlange.
  • Beschreiben vereinzelter Ereignisse und Schreiben von Code zum Steuern des Überlaufverhaltens der Ankunftszeit-Warteschlange.


Probleme und Muster bei Speicher mit Geltungsbereich

  • Kenntnis von Speicherzuweisungsregeln.
  • Beschreiben der Single-Parent-Regel und des aktiven Bereichsstacks eines Threads.
  • Beschreiben von Speicherbereichen und Bibliotheks-APIs.
  • Beschreiben und Implementieren des eingekapselten Methodenmusters (encapsulated method).
  • Beschreiben des eingekapselten Methoden-Musters.


Komponentenstatusmuster

  • Identifizieren und Unterscheiden von Komponentenstatus und -lebensdauern.
  • Beschreiben und Implementieren des Objektmusters mit mehrfachem Geltungsbereich (multi-scoped object).
  • Beschreiben und Verwenden des Portal-Objekts eines ScopedMemory-Objekts.
  • Beschreiben von für Portale geeigneten Concurrency-Ansätzen (Nebenläufigkeit).
  • Beschreiben und Implementieren des Keil-Thread-Musters (wedge thread).
  • Beschreiben von Ansätzen zum Verschieben von Daten zwischen Bereichen.
  • Beschreiben und Implementieren des Abgabemusters (handoff).


Asynchrone Steuerungsübergabe

  • Beschreiben des Zwecks der asynchronen Übergabe der Steuerung (Asynchronous Transfer of Control, ATC).
  • Beschreiben und Verwenden der ATC-API.
  • Beschreiben und Implementieren des zeitlich abgestimmten Algorithmus-Musters (timed algorithm).
  • Schreiben von unterbrechungsfähigem Code und Code, der nötigenfalls Unterbrechungen verschiebt.


Pipeline-Architektur

  • Beschreiben der Pipeline-Architektur.
  • Kenntnis, wie Synchronisierung zwischen Nicht-Heap-Echtzeit-Threads

    und Heap-fähigen Threads die Echtzeitvorhersagbarkeit zerstören kann.
  • Beschreiben und Verwenden von verzögerungsfreien Warteschlangen.
  • Kenntnis der Hauptprobleme bei der Implementierung der Pipeline-Architektur.
  • Auflisten der Vorteile und Kosten der Pipeline-Architektur.
  • Auflisten der Vorteile und Kosten einer verteilten Pipeline-Architektur.


Kurssprache deutsch, Unterrichtsmaterial überwiegend in englischer Sprache.


Vergleichen Sie diesen Kurs mit ähnlichen Kursen
Mehr ansehen