Un dirigeant cyclique offre une alternative à l'écriture d'un système d'exploitation à part entière, en temps réel . Il se compose d' une boucle infinie qui contient des jeux d'action. Chaque ensemble est précédé d'une période d'attente qui détermine le moment où le jeu consiste à effectuer ses actions. Le code suivant donne un exemple : while ( true) { //attendre 3 secondswait (3000) ;//recevoir un message de réseau ....... //attendre 2 secondes pour la réception complète de la messagewait (2000 ) ;//analyser le contenu du message ....... } Ces jeux d'action peuvent souvent fonctionner simultanément avec un certain degré de synchronisation . En Java , les threads sont un mécanisme pour l'exécution de tâches simultanées en utilisant des pauses pour aider à la synchronisation. Instructions Comment identifier les tâches
1

Sélectionnez un modèle de conception qui se rapproche le plus des exigences de comportement de l'application doit être construit comme un cadre cyclique. Assurez-vous que le modèle de conception porte sur le contenu de la boucle qui composent l'exécutif cyclique.
2

Paire les comportements du modèle de conception avec les exigences de l'application . Assurez-vous que chacun des coopérants , des processus synchronisés est associée à chacun des comportements décrits dans la demande .
3

Identifier les détails spécifiques à Java qui composent chacune des classes de la discussion du processus de l'application. Assurez-vous de mettre en place une pause de synchronisation pour chaque classe de thread de processus pour assurer un bon timing entre les processus et éviter les situations anormales telles que les courses . Créer des classes de soutien à agir comme des tampons d'échange de données entre les processus , tels que les files d'attente , au besoin. Créer une classe de flux de journal pour définir journaux de suivi de l'exécution de chaque thread de processus .
Organiser de manière
4

Créer une classe principale exécutif cyclique qui instancie les classes de la discussion du processus , classes de soutien et toute autre initialisation requis , tels que les suivants :
classe

CyclicExec { public static void main ( string [] args ) {//initialiser les ressources nécessaires .......... ........................... //définir un filet journal classLogStream ls = new LogStream (); ......... ............................ //initialiser les classes de soutien ................. .................... MsgQueue sq = new MsgQueue (....) ; .................. ................... //initialiser les classes de thread de processus ......................... ............ //instancier le processus Processus_1 et définir sa = new Processus_1 (......) associé threadProcess_1 p1 ; T_Process_1 = new Thread (p1 ) ;//activer le fil pour Process_1try { T_Process_1.start (); } catch ( IllegalThreadStateException e) {//Se connecter un mauvais début de fil et de sortie .......................... ........... }}}
5

Ajouter au forfait de chacune des classes de la discussion du processus , comme le montre l'exemple suivant :
classe

Processus_1 s'étend discussion {//initializationpublic Processus_1 (.... ) {//configurer un journal pour ce thread ( p_s est objet de flux journal prédéfini) PrintStream p1_s = p_s.make_it ( Processs_1_Log_File ) ;//initialiser le thread de processus .. ................................... } .............. ....................... //exécution - poussé par la méthode start () implicite utilisée dans la principale void run classpublic () {//core loopwhile ( true) { //processus de base ..................................... //pause après l'exécution d' un le cycle du noyau processtry { sommeil ( Process_1_Wait ) ; } catch ( e InterruptedException ) {//connecter une exception pause .......................... ............. }}}}
6

Créer des classes de soutien qui définissent tampons messagerie entre les threads de processus avec ses méthodes d'accès tampons qualifié comme synchronisée, comme suit montre l'exemple :

publique synchronisé octet PushIt (octet ITM) { ................................ ............................. }
7

Créer une classe spéciale qui définit les fichiers journaux de traçage le comportement des classes de la discussion du processus , tels que:
classe

LogStream {private boolean LogState ;//classe initializerpublic LogStream (String LogStateIn ) { this.LogState = false; if ( LogStateIn.equals ( "oui" ) ) this.LogState = true; } //créer un flux de journal à un filepublic PrintStream make_it (String LogLocation ) { PrintStream This1 ; Chaîne ces impératifs2 ; if ( this.LogState ) { ces impératifs2 = new String ( LogLocation );} else { ces impératifs2 = new String (" /dev /null ");} try { This1 = new PrintStream ( nouveau FileOutputStream ( ces impératifs2 , true) ) ; } catch (Exception e) { This1 = null; } return This1 ;}}

tester et livrer
8

définir une séquence de scénarios de tests pour couvrir les conditions de fonctionnement les deux extrêmes et normale afin d'affiner la synchronisation entre les threads de processus .
9

examen le thread de processus se connecte à faire en sorte que les classes de la discussion du processus fonctionnent comme prévu. Assurez-vous qu'aucun courses ou des conditions similaires se sont produites .
10

Préparer le package de distribution d'applications en incluant les fichiers de classe ( exécutable) pour chacun des threads de processus , la classe principale , les classes de support de messagerie et de flux du journal classe . Inclure les scripts qui débarquent et mettent en place les fichiers de classe ainsi que d'initialiser le répertoire où les fichiers journaux de fil de processus doivent être situés .