Come codice di un esecutivo ciclico in Java

Un dirigente ciclico fornisce un'alternativa alla scrittura di un sistema operativo in piena regola in tempo reale . Consiste in un ciclo infinito che contiene insiemi di azioni . Ogni set è preceduto da un periodo di attesa che controlla quando il set è quello di eseguire le sue azioni . Il codice che segue fornisce un esempio : while (true ) { //attendere 3 secondswait ( 3000) ;//ricevere un messaggio di rete ....... //attendere 2 secondi per la completa ricezione del messagewait ( 2000) ;//scansione del contenuto del messaggio ....... } Questi gruppi di azioni spesso possono funzionare contemporaneamente ad un certo grado di sincronizzazione . In Java , le discussioni sono un meccanismo per l'esecuzione di attività simultanee con pause per assistere nella sincronizzazione.
Istruzioni di individuare i compiti
1

Selezionare un modello di progettazione che è più vicina alle esigenze comportamento dell'applicazione ad essere costruita come un esecutivo ciclico . Assicurarsi che il modello di progettazione riguarda il contenuto del loop che compongono l'esecutivo ciclico .
2

Coppia i comportamenti del modello di progetto con i requisiti di applicazione . Assicurarsi che ciascuna delle sincronizzati , processi cooperanti è associato con ciascuno dei comportamenti descritti nella domanda.
3

Identificare i dettagli Java - specifici che compongono ciascuna delle classi di thread di processo dell'applicazione . Assicurarsi di impostare una pausa di sincronizzazione per ogni processo classe Thread per assicurare una corretta sincronizzazione tra processi e di evitare condizioni anomale come la corsa . Creare classi di supporto per agire come buffer di scambio dei dati tra i processi , come ad esempio le code , se necessario. Creare una classe flusso di registrazione per definire i registri di traccia l'esecuzione di ogni thread di processo .
Organizza il pacchetto
4

Costruire una classe principale dirigente ciclica che crea un'istanza delle classi thread di processo , classi di sostegno speciali e ogni altra inizializzazione richiesto , come ad esempio il seguente :
classe

CyclicExec { static void main ( String [] args ) { pubbliche //inizializzare occorrono risorse .......... ........................... //definisce un filo log classLogStream ls = new LogStream ( ) ; ......... ............................ //inizializzare classi di supporto ................. .................... MsgQueue mq = new MsgQueue ( .... ) ; .................. ................... //inizializzare classi di thread di processo ......................... ............ //creare l'istanza del processo Process_1 e definire il suo associato threadProcess_1 p1 = new Process_1 ( ...... ) ; T_Process_1 = new Thread ( p1 ) ;//attivare il filo per Process_1try { T_Process_1.start (); } catch ( IllegalThreadStateException e) { //log una brutta partenza filo e uscita .......................... ........... } } }
5

Aggiungi al pacchetto di ciascuna delle classi di thread di processo , come nel seguente esempio :
classe

Process_1 estende Discussione { //initializationpublic Process_1 ( .... ) { //creare un log per questa discussione ( P_S è pre -definito oggetto flusso di log ) PrintStream p1_s = p_s.make_it ( Processs_1_Log_File ) ;//inizializza il thread del processo .. ................................... } .............. ....................... //esecuzione - spinto attraverso il metodo start implicito ( ) utilizzato nel main classpublic void run ( ) { //core loopwhile ( true) { //processo centrale ..................................... //pausa dopo l'esecuzione di una ciclo del nucleo processtry { sleep ( Process_1_Wait ) ; } catch ( InterruptedException e) { //log un'eccezione pausa .......................... ............. } } } }
6

costruire le classi di supporto che definiscono i buffer di messaggistica tra i thread di processo con i suoi metodi di accesso tampone qualificato come sincronizzati , come il seguente mostrato nell'esempio :

pubblico sincronizzato Pushit byte ( byte Itm ) { ................................ ............................. }
7

Costruire una classe speciale che definisce i file di registro di traccia il comportamento delle classi di thread di processo , come ad esempio :
classe

LogStream {private boolean LogState ;//classe initializerpublic LogStream (String LogStateIn ) { this.LogState = false; if ( LogStateIn.equals ( " sì" ) ) this.LogState = true ; } //creare un flusso di log a un filepublic PrintStream make_it (String LogLocation ) { PrintStream This1 ; String questa necessità2 ; se ( this.LogState ) { questa necessità2 = new String ( LogLocation );} else { questa necessità2 = new String ( " /dev /null ");} try { This1 = new PrintStream ( new FileOutputStream ( questa necessità2 , true) ) ; } catch ( Exception e) { This1 = null; } return This1 ; } }

test e Deliver
8

definire una sequenza di scenari di test per coprire condizioni di funzionamento sia estreme e normale al fine di perfezionare la sincronizzazione tra i thread di processo.
9

Review il thread del processo log per assicurarsi che le classi di thread di processo gestite come previsto. Accertarsi che non da corsa o condizioni simili si sono verificati .
10

Preparare il pacchetto di distribuzione delle applicazioni , includendo i file di classe (eseguibili ) per ciascuno dei thread di processo , la classe principale , le classi di supporto di messaggistica e flusso di log classe . Includere script che scaricano e impostare i file di classe così come inizializzare la directory in cui i file di log thread di processo devono essere situate .