Modul 1 - 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.

Modul 2 - 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.

Modul 3 - 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.

Modul 4 - 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).

Modul 5 - 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.

Modul 6 - 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.

Modul 7 - 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.

Modul 8 - 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.

Modul 9 - 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).

Modul 10 - 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.

Modul 11 - 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.

Kursmaterialien in englischer Sprache.