Developing Real Time Applications for the Java Platform

RPS Consulting pvt Ltd
In Bangalore

Rs 24,000
You can also call the Study Centre
99019... More
Students that were interested in this course also looked at...
See all

Important information

  • Course
  • Bangalore
  • Duration:
    5 Days

Design, write, and debug programs using Java 1.4. Make use of inner classes, including anonymous inner classes. Make use of the threading facilities of Java 1.4. Who Can Benefit

Important information

Where and when

Starts Location
On request
560 025, Karnataka, India
See map

Course programme

DTJ-4103 Developing Real-Time Applications for the Java Platform
Course Content :: Duration :: Course Fees
5 days

INR 24000.0 plus service taxes

The Developing Real-Time Applications for the Java Platform course provides students with the essential skills required to use the real-time capabilities of the Real-Time Specification for Java (RTSJ) to create real-time applications.


· Control garbage collection induced jitter in thread release
· Create RealtimeThread objects, and use SchedulingParameters and PeriodicParameters to control thread behavior
· Control concurrent access to resources and describe priority inversion and the priority inheritance algorithm
· Understand the constraints that apply when using objects in non-heap memory, and issues that might arise when using library APIs in non-heap memory
· Use AsyncEvent, OneShotTimer, PeriodicTimer, and AsyncEventHandler objects to provide timed and asynchronous behavior
· Control the queueing of asynchronous events to limit the impact of out-of-spec events or handlers on other parts of a system
· Interrupt threads asynchronously and control their behavior under such conditions
· Use portals to access scoped memory
· Describe and use appropriately the scoped run loop, encapsulated method, handoff, timed algorithm, multi-scoped object, wedge thread pattern
· Use overrun handlers to limit the impact of out-of-spec threads on other parts of a system


To succeed fully in this course, students should be able to:
· Design, write, and debug programs using Java 1.4
· Make use of inner classes, including anonymous inner classes
· Make use of the threading facilities of Java 1.4

Who Can Benefit

Students who can benefit from this course are programmers, developers, and software architects who will be involved in development of real-time systems using the Java programming language with the RTSJ extensions. Students should be fluent in the Java programming Language up to version 1.4 and should be have some familiarity with the nature of real-time programming, though extensive prior experience is not required.

Duration :5 days

Course Fees :INR 24000.0 plus service taxes

INR 26966.40 inclusive of service taxes

Course Content :
Introduction to Real-Time Programming and the Sun Java Real-Time System
· Describe real-time programming, RTSJ and the Java Real-Time System
· Outline the relationships between Input/Output (I/O), resource contention, garbage collection, and real-time systems
· Outline memory types provided by RTSJ
· Describe fundamental real-time architectures
· Create a periodic real-time thread
· Measure the latency and jitter of a periodic real-time thread

Interacting With the Real World
· Design objects that give access to devices
· Design objects for use in a real-time system
· Describe actuators and sensors
· Describe ways of connecting hardware to computers
· Outline the use of raw or physical memory
· Select the appropriate techniques for handling external events

Creating the Timeline Executive
· Determine time constraints affecting tasks
· Determine a base frequency for a timeline
· Implement a timeline executive
· Determine and control frame costs
· Describe benefits and costs of the timeline architecture

Applying the Scoped Run Loop PatternModule
· Describe the impact of garbage collection on real-time response
· Describe how immortal and scoped memory spaces can avoid garbage collection effects and how objects in these spaces are recovered
· Describe scoped memory rules
· Recognize predictability issues with NHRT threads
· Configure and use initialization-time compilation
· Describe and implement the scoped run-loop pattern

Introduction to the Event-Driven ArchitectureModule
· Describe event-driven architecture
· List the advantages and disadvantages of event-driven architecture
· Describe how a single CPU is scheduled when multiple threads of differing priorities are runnable
· Describe real-time object design
· Design sound objects for a real-time system
· Schedule and dispatch in the RTSJ
· Write code for active components in RTSJ
· Add events to the simulation

Data Synchronization for Concurrent Tasks
· Design for data synchronization
· Implement data synchronization using the synchronized keyword
· Recognize critical sections and protect them with synchronized blocks
· Describe priority inversion and priority inversion avoidance techniques
· Describe the Java SE 5.0 concurrency utilities
· Describe the arbitration policies for multiple shared resources

Handling Asynchronous Events
· Describe asynchronous event handling
· Describe asynchronous event handlers and real-time threads
· Write code to handle a POSIX signal
· Create application-defined events
· Write code to issue an event under program control
· Describe aperiodic events and write code to control arrival time queue overflow behavior
· Describe sporadic events and write code to control arrival time queue overflow behavior

Scoped Memory Issues and Patterns
· Understand memory assignment rules
· Describe the single-parent rule and a threads active scope stack
· Describe memory areas and library APIs
· Describe and implement the encapsulated method pattern
· Describe the encapsulated method pattern

Component State Patterns
· Identify and differentiate component state and lifetimes
· Describe and implement the multi-scoped object pattern
· Describe and use the portal object of a ScopedMemory object
· Describe concurrency approaches suited to portals
· Describe and implement the wedge thread pattern
· Describe approaches for moving data between scopes
· Describe and implement the handoff pattern

Asynchronous Transfer of Control
· Describe the purpose of asynchronous transfer of control (ATC)
· Describe and use the ATC API
· Describe and implement the timed algorithm pattern
· Write interruptible code, and code that defers interrupts when necessary

Pipeline Architecture
· Describe the pipeline architecture
· Understand how synchronization between no-heap realtime threads and heap-aware threads can destroy realtime predictability
· Describe and use wait-free queues
· Understand key issues in the implementation of the pipeline architecture
· List benefits and costs of the pipeline architecture
· List benefits and costs of a distributed pipeline architecture

Related Courses (Before)

Related Courses (After)

Achievements for this centre

Students that were interested in this course also looked at...
See all