Java >> Tutoriel Java >  >> Java

Utilisation de Sun Java Real-Time System

Eric J. Bruno, co-auteur de Real-Time Java Programming with Java RTS, présente une introduction à l'utilisation de Java RTS pour créer des solutions Java en temps réel.

Sun Java Real-Time System (Java RTS) est une implémentation de machine virtuelle Java conforme à la spécification Real-Time pour Java (RTSJ). Les applications Java en temps réel sont soumises à une certaine forme de contrainte de temps. Par exemple, si votre application doit effectuer un traitement à des intervalles de temps précis, ou doit répondre à un événement dans un délai bien défini (un délai), alors vous avez une exigence en temps réel.

La création d'applications en temps réel est un défi car vous devez garantir que votre code respecte son échéance de manière prévisible et déterministe. Java SE ne peut généralement pas respecter cette garantie en raison du comportement non déterministe du ramasse-miettes et du compilateur juste-à-temps (JIT), et de l'absence de répartition stricte des threads basée sur la priorité. Java RTS et le RTSJ résolvent ces défis en définissant comment les applications Java doivent se comporter dans l'espace temps réel. Java RTS fournit le runtime, les API et les outils nécessaires pour analyser et contrôler le comportement temporel de vos applications Java.

Basé sur la base de code Java SE 5, Java RTS s'exécute sur Solaris 10, Red Hat MRG Linux et SUSE Linux Enterprise Real-Time Extension de Novell (Red Hat et SUSE sont des produits Linux temps réel POSIX). Bien que ces distributions de système d'exploitation soient officiellement prises en charge, vous pouvez faire en sorte que Java RTS s'exécute sur le dernier noyau Linux avec le RT-PREEMPT correctifs installés (une exigence pour obtenir un comportement en temps réel sous Linux). Examinons quelques-unes des fonctionnalités de Java RTS pour le développement Java en temps réel.

Le Thread en temps réel Classe

Pour que votre code s'exécute avec des caractéristiques déterministes en temps réel dans Java RTS, vous devez l'exécuter dans un thread en temps réel. Pour ce faire, créez une classe qui étend le Runnable interface et créez un javax.realtime.RealtimeThread (RTT) à la place d'un java.lang.Thread pour exécuter votre code d'application (voir Listing 1).

Liste 1 :Exécuter un Runnable dans un RealtimeThread .

import javax.realtime.*;
public class MyApp {
    class MyRunnable implements Runnable {
        public MyRunnable() {
            // ...
        }

        public void run() {
            // Application logic here...
        }
    }

    public MyApp() {
        // Run at realtime priority
        PriorityParameters sched =
            new PriorityParameters(
                PriorityScheduler.instance().getMinPriority());

        // Create the RealtimeThread to execute the runnable
        RealtimeThread rtt = new RealtimeThread(
                  sched,              // priority
                  null,               // release parameters
                  null,               // memory parameters
                  null,               // memory area
                  null,               // processing group
                  new MyRunnable() ); // The runnable

        rtt.start();
    }

    public static void main(String[] args) {
        MyApp main = new MyApp();
    }
}

Alternativement, votre classe peut étendre RealtimeThread directement (voir Listing 2). Définissez la priorité de votre RTT et d'autres caractéristiques en temps réel (facultatives), et démarrez-le comme vous le feriez avec n'importe quel Thread . Vous pouvez éventuellement définir la priorité et démarrer le RTT dans MyRealtimeClass constructeur, masquant les détails de l'implémentation en temps réel à l'appelant.

Liste 2 :Extension de RealtimeThread .

import javax.realtime.*;
public class MyApp {
    class MyRealtimeClass extends RealtimeThread {
        public MyRealtimeClass() {
            // ...
        }

        public void run() {
            // Application logic here...
        }
    }

    public MyApp() {
        // Run at realtime priority
        PriorityParameters priority =
            new PriorityParameters(
                PriorityScheduler.instance().getMinPriority());

        MyRealtimeClass rtt = new MyRealtimeClass();
        rtt.setSchedulingParameters( priority );
        rtt.start();
    }

    public static void main(String[] args) {
        MyApp main = new MyApp();
    }
}

Selon vos besoins, vous devrez peut-être effectuer le traitement à intervalles réguliers. Java RTS prend en charge les threads temps réel périodiques; grâce à sa fonction de minuterie haute résolution, il garantit que votre code RTT est publié à des moments précis pour répondre à ses besoins périodiques. Pour invoquer ce comportement, vous créez un PeriodicParameters objet, définissez la période de temps et définissez-la comme paramètre de libération de votre RTT (voir Listing 3). Le code affiché en gras illustre les changements par rapport à l'exemple précédent.

Liste 3 :Définir un RealtimeThread périodique .

// ...

// Run at realtime priority
PriorityParameters priority =
    new PriorityParameters(
        PriorityScheduler.instance().getMinPriority());

// 10 millisecond periodic release
RelativeTime tenMillis = new RelativeTime( 10, // millisecods
                                           0); // nanoseconds
ReleaseParameters period =
    new PeriodicParameters( tenMillis ); 
MyRealtimeClass rtt = new MyRealtimeClass();
rtt.setSchedulingParameters( priority );
rtt.setReleaseParameters( period ); 
rtt.start();

// ... 

Java RTS vous permet de définir des priorités de thread afin que vous puissiez contrôler avec précision l'ordre de traitement au sein de votre application. De plus, par défaut, le code d'un RTT s'exécute avec une priorité plus élevée que le ramasse-miettes. Cette configuration élimine l'imprévisibilité associée au collecteur de Java SE et élimine la plupart des latences associées à la récupération de place pour votre code urgent. Examinons brièvement le ramasse-miettes en temps réel dans Java RTS.


Balise Java