Threads di controllo in Java

I programmatori sono al corrente dei programmi sequenziali di scrittura. Il programma che visualizza �ciao il mondo! �, o programma che fascicola una lista dei nomi, o computa la lista dei numeri principali, sono sequenziale tutti i programmi: ciascuno ha inizio, estremit�, sequenza ed a tutto il dato tempo durante il tempo di esecuzione del programma ci � unico dell'esecuzione.

Un Thread � simile ad un programma sequenziale, un singolo Thread inoltre ha inizio, l'estremit�, sequenza ed a tutto il dato tempo durante il tempo di esecuzione del Thread ci sar� un unico dell'esecuzione. Ma il Thread in se non � un programma che non possa funzionare se ma dai funzionamenti nell'ambito del programma.

Esempio semplice del Thread

Il seguente esempio � un'applicazione semplice del Java che generer� ed inizier� due Threadsindipendenti.

class TwoThreadssTest
{
public static void main (String args[])
{
new SimpleThreads("Japan").start();
new SimpleThreads("India").start();
}
}

class SimpleThreads extends Threads
{
public SimpleThreads(String str)
{
super(str);
}
public void run()
{
for (int i = 0; i < 10; i++)
{
System.out.println(i + " " + getName());
try
{
sleep((int)(Math.random() * 1000));
} catch (InterruptedException e)
{}
}
System.out.println("DONE! " + getName());
}
}

Il primo metodo nel codice categoria di SimpleThreads � un costruttore che prende soltanto la stringa come relativa discussione. Questo costruttore � effettuato denominando i superclass costruttore ed � interessante perch� regola il nome del Thread che � usato pi� successivamente nel programma.

Il metodo seguente in questo codice categoria � () metodo funzionato. il metodo di funzionamento () � il cuore di tutto il filetto, questo � dove l'azione del Thread avviene. Il metodo di funzionamento () nel codice categoria di SimpleThreads contiene la a per il ciclo che ripete dieci volte. In ciascuna della ripetizione visualizza il numero di ripetizione ed il nome del Thread ed allora dorme per l'intervallo casuale di tempo fra 0 e 1 secondo. Dopo la rifinitura del ciclo, il metodo di funzionamento () stampa �FATTO!� con il nome del filetto.

Attributi di un Thread

Tutta l'azione avviene nel corpo del filetto, nel metodo di funzionamento del Thread (). Possiamo fornire il corpo al Thread in uno dei due sensi: in primo luogo subclassing un codice categoria del Thread ed escludendo il metodo di funzionamento () del filetto, secondariamente generando un Thread con l'oggetto praticabile come relativo obiettivo.

Corpo di un Thread

I Threadsdel Java sono effettuati usando il codice categoria del Thread che � la parte del pacchetto di java.lang. Un codice categoria del Thread effettua la definizione indipendente del sistema dei Threadsdel Java. Ma, l'esecuzione reale dell'operazione simultanea � fornita tramite l'esecuzione sistema-specifica. Per la maggior parte dei bisogni di programmazione, l'esecuzione di fondo non importa; possiamo ignorare l'esecuzione di fondo e programmare il Thread api e l'altra documentazione fornita del sistema del Java.

Dichiara di un Thread

Durante la vita, il Thread del Java sar� in uno fra vari dichiara. Il dichiarare di un Thread indica che cosa il Thread sta facendo attualmente e che cosa pu� fare a quel periodo della relativa vita: se esso sta funzionando? sta dormendo? o � guasto? Questi dichiarano sono illustrati sotto.

Nuovo filetto
La dichiarazione sotto genera un nuovo Thread ma non lo inizier� quindi a lasciare il Thread in un dichiarare identificato �nuovo filetto�.

Threads myThreads = new MyThreadsClass();

Quando il Thread � in �nuovo filetto� dichiarare, soltanto esso � un oggetto vuoto del filetto. Nessuna risorsa del sistema � stanziata per esso ancora. Cos� quando il Thread � in questo dichiarare, noi pu� iniziare o arrestare soltanto il filetto; quando un Thread � in questo dichiarare la chiamata dei c'� ne dell'altro metodo oltre all'inizio () o arresto () non avr� alcun significato e non causa un IllegalThreadsStateException.

Praticabile
Il metodo di inizio () genera tutte le risorse di sistema necessarie per fare funzionare un filetto, programma il Thread per funzionare ed il metodo di funzionamento del Thread di chiamate ().

Threads myThreads = new MyThreadsClass();
myThreads.start();

A questo punto il Thread � �in praticabile� dichiara. Ci� dichiara � chiamata �praticabile� dichiara piuttosto che �funzionando� dichiarare perch� il Thread non pu� funzionare realmente quando � in questo dichiara. Molti calcolatori hanno un singolo processor renderli impossible fare funzionare tutti i Threads�praticabili� allo stesso tempo. Di conseguenza il sistema runtime del Java dovrebbe effettuare lo schema di programmazione che ripartisce il processor fra tutti i Threads�praticabili�. Per la maggior parte degli scopi tuttavia, possiamo pensare �a praticabile� dichiariamo come semplicemente �funzionando�. Quando un Thread sta funzionando, � �praticabile� ed � il Thread corrente. Le istruzioni nel metodo di funzionamento () stanno eseguendo in sequenza.

Non praticabile
Un Thread prendpartee �a non praticabile� dichiara quando uno di seguenti eventi accade:

Quando un metodo di sospensione () � denominato
Quando un metodo di sonno () � denominato
Quando il Thread usa il relativo metodo di attesa () per aspettare una variabile di circostanza
Quando il Thread sta ostruendo su ingresso/uscita.

Threads myThreads = new MyThreadsClass();
myThreads.start();
try
{
myThreads.sleep(10000);
} catch (InterruptedException e)
{
}

La linea GRASSETTO nel suddetto esempio mette il myThreads per dormire per 10 secondi. Durante questi 10 secondi, anche se il processor diventa disponibile il myThreads non funzioner�. Dopo 10 secondi finito, il myThreads diventa ancora �praticabile� e se il processor � disponibile funzionerebbe.

Seguire le dichiarazione indica che l'uscita d'emergenza per ogni entrata �in non praticabile� dichiara.

Se il Thread � messo per dormire, allora il tempo specificato dovrebbe trascorrere.
Se il Thread � sospeso, allora qualcuno deve denominare il metodo del resume ().
Se il Thread sta attendendo sulla variabile di circostanza, che cosa oggetto possiede la variabile dovrebbe cedere questa denominando informa () o metodo del notifyAll ().
Se il Thread � ostruito su ingresso/uscita, quindi l'ordine specificato dell'ingresso/uscita dovrebbe ottenere completo.

Guasto
Un Thread pu� morire in due sensi differenti: uno da una causa naturale, o essendo uccidendo (arrestato). Un Thread si dice per morire naturalmente quando il metodo di funzionamento () rimuove normalmente. Cosider per esempio, il ciclo di istante nel metodo di funzionamento � un ciclo limitato, ripeter� 100 volte ed allora smette di eseguire.

public void run()
{
int i = 0;
while (i < 100)
{
i++;
System.out.println("i = " + i);
}
}

Possiamo anche uccidere in qualunque momento semplicemente un Thread denominando il metodo di arresto (). Ci� � secondo le indicazioni del codice qui sotto:

public void run()
{
Threads myThreads = new MyThreadsClass();
myThreads.start();
try
{
Threads.currentThreads().sleep(10000);
} catch (InterruptedException e)
{
}
myThreads.stop();
}

Il metodo di funzionamento qui genera e myThreads di inizio allora mette il Thread corrente per dormire per circa 10 secondi. Quando il Thread corrente sveglia, la linea GRASSETTO nel segmento di codice uccider� il myThreads.

Il metodo di arresto () getter� un oggetto di ThreadsDeath per uccidere il filetto. Quando il Thread � ucciso in questo modo muore asynchronously. Il Thread morir� quando realmente riceve un'eccezione di ThreadsDeath.

IllegalThreadsStateException
il sistema runtime getta un IllegalThreadsStateException quando denominiamo un metodo su un Thread ed il Thread dichiara non terr� conto quella chiamata di metodo. Per esempio, IllegalThreadsStateException � gettato quando denominiamo un metodo di sospensione () su un Thread che non � �praticabile�.

Secondo negli esempi dei Threadsstudiati finora in questo capitolo, quando denominiamo un metodo del Thread che pu� gettare un'eccezione, dovreste interferire e maneggiare l'eccezione, o dovreste dichiarare quello, l'eccezione di chiamata del uncaught dei tiri di metodo.

public void run()
{
Threads myThreads = new MyThreadsClass();
myThreads.start();
try
{
Threads.currentThreads().sleep(10000);
} catch (InterruptedException e)
{
}
myThreads.stop();
}

() metodo isAlive

Se il metodo che () i ritorni isAlive allineare allora filettano � iniziato e non � interrotto. Quindi, se () il metodo isAlive restituisce falso sappiamo che il Thread � uno �nuovo filetto� o quello �guasto�. Se () il metodo isAlive restituisce allineare, allora il Thread siete �praticabili� o �non praticabili�.

Priorit� del Thred

Quando un Thread del Java � generato, eredita la priorit� dal Thread che la ha generata. Possiamo anche modificare in qualunque momento la priorit� del Thread dopo la relativa creazione usando il setPriority di metodo (). Le priorit� dei Threadssvariano da MIN_PRIORITY a MAX_PRIORITY (questi sono i costanti definiti in Thread del codice categoria). A tutto l'dato istante di tempo, quando i Threadssmultipli sono aspettare per eseguire, il sistema runtime sceglie il Thread �praticabile� che ha la netta priorit� per l'esecuzione. Soltanto quando questo Thread si arresta, rende, o diventa �non praticabile� per una certa specie di motivo, l'esecuzione pi� di scarsa priorit� di inizio del filetto. Se ci sono due Threadsche hanno stesso CPU attendente di priorit�, il programmatore li sceglier� ad un modo del rotondo-pettirosso.

Threads del Daemon

Tutto il Thread del Java pu� essere Thread del daemon. I Threadsdel Daemon sono fornitori di servizio per quei Threadso oggetti che funzionano nello stesso processo come il Thread del daemon sta facendo funzionare. Per esempio, il browser di HotJava ha un Thread del daemon, denominato lettore di immagine di priorit� bassa, che legge le immagini dal sistema di lima o la rete per c'� ne dell'oggetto o del Thread che ha bisogno di un'immagine.