Fils de commande dans Java

Les programmeurs sont au courant des programmes s�quentiels d'�criture. Le programme qui montre ��bonjour le monde ! ��, ou le programme qui assortit une liste de noms, ou calcule la liste de nombres principaux, sont s�quentiels tous les programmes : chacun a commencer, extr�mit�, ordre, et � n'importe quelle heure donn�e pendant le temps d'ex�cution du programme il y a seul point d'ex�cution.

Un fil est semblable � un programme s�quentiel, un fil simple a �galement commencer, extr�mit�, ordre, et � n'importe quelle heure donn�e pendant le temps d'ex�cution du fil il y aura un seul point d'ex�cution. Mais le fil lui-m�me n'est pas un programme qu'il ne peut pas ex�cuter par lui-m�me mais des courses dans le programme.

Exemple simple de fil

L'exemple suivant est une application simple de Java qui cr�era et commencera deux fils ind�pendants.

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

class SimpleThread extends Thread
{
public SimpleThread(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());
}
}

La premi�re m�thode dans la classe de SimpleThread est un constructeur qui prend seulement la corde en tant que son argument. Ce constructeur est mis en application en appelant les superclass constructeur et est int�ressant parce qu'il place le nom du fil qui est employ� plus tard dans le programme.

La prochaine m�thode dans cette classe est () m�thode courue. la m�thode de course () est le coeur de n'importe quel fil, ceci est o� l'action du fil a lieu. La m�thode de course () dans la classe de SimpleThread contient a pour la boucle qui r�it�re dix fois. Dans chacune de l'it�ration elle montre le nombre d'it�ration et le nom du fil et puis dort pour l'intervalle al�atoire du temps entre 0 et 1 seconde. Apr�s avoir fini la boucle, la m�thode de course () imprime ��FAIT !�� avec le nom du fil.

Attributs d'un fil

Toute action a lieu dans le corps du fil, dans la m�thode de la course du fil (). Nous pouvons fournir le corps au fil dans une des deux mani�res : d'abord subclassing une classe de fil et en d�passant la m�thode de course () de fil, deuxi�mement en cr�ant un fil avec l'objet praticable en tant que sa cible.

Corps d'un fil

Des fils de Java sont mis en application en employant la classe de fil qui est la partie du paquet de java.lang. Une classe de fil met en application la d�finition ind�pendante de syst�me des fils de Java. Mais, l'ex�cution r�elle du fonctionnement concurrent est fournie par l'ex�cution syst�me-sp�cifique. Pour la plupart des besoins de programmation, l'ex�cution fondamentale n'importe pas ; nous pouvons ignorer l'ex�cution fondamentale et programmer le fil api et toute autre documentation �quip�e de syst�me de Java.

�tats d'un fil

Durant toute la vie, le fil de Java sera dans un parmi plusieurs �tats. L'�tat d'un fil indique ce que le fil fait actuellement et ce qu'il peut faire � ce moment-l� de sa vie : s'il court ? dort ? ou est mort ? Ces �tats sont illustr�s ci-dessous.

Nouveau fil
Le rapport ci-dessous cr�e un nouveau fil mais il ne le commencera pas � laisser de ce fait le fil dans un �tat marqu� ��nouveau fil��.

Thread myThread = new MyThreadClass();

Quand le fil est dans l'�tat de ��nouveau fil��, simplement c'est un objet vide de fil. Aucune ressource de syst�me n'est allou�e pour lui encore. Ainsi quand le fil est dans cet �tat, nous pouvons seulement commencer ou arr�ter le fil ; quand un fil dans cet �tat appelle l'un des l'autre m�thode sans compter que le d�but () ou l'arr�t () ne semblera aucun raisonnable et ne cause pas un IllegalThreadStateException.

Praticable
La m�thode de d�but () cr�e toutes ressources de syst�me n�cessaires pour courir un fil, elle programme le fil pour fonctionner, et la m�thode de la course du fil d'appels ().

Thread myThread = new MyThreadClass();
myThread.start();

En ce moment le fil est dans l'�tat ��praticable��. Cet �tat s'appelle �tat ��praticable�� plut�t que l'�tat ��fonctionnant�� parce que le fil peut ne pas fonctionner r�ellement quand il est dans cet �tat. Beaucoup d'ordinateurs ont un processeur simple le rendre impossible de courir tous fils ��praticables�� en m�me temps. Par cons�quent le syst�me d'ex�cution de Java devrait mettre en application l'arrangement de �tablissement du programme qui partage le processeur entre tous fils ��praticables��. Pour la plupart des buts cependant, nous pouvons penser � l'�tat ��praticable�� comme simplement ��courant��. Quand un fil fonctionne, il est ��praticable�� et est le fil courant. Les instructions dans la m�thode de course () s'ex�cutent s�quentiellement.

Non praticable
Un fil entre dans l'�tat ��non praticable�� quand un d'�v�nements suivants se produisent :

Quand une m�thode de suspension () s'appelle
Quand une m�thode de sommeil () s'appelle
Quand le fil emploie sa m�thode d'attente () pour attendre une variable de condition
Quand le fil bloque sur l'entr�e-sortie.

Thread myThread = new MyThreadClass();
myThread.start();
try
{
myThread.sleep(10000);
} catch (InterruptedException e)
{
}

La ligne audacieux dans l'exemple ci-dessus met le myThread pour dormir pendant 10 secondes. Pendant ces 10 secondes, m�me si le processeur devient disponible le myThread ne fonctionnera pas. Apr�s 10 secondes plus de, le myThread devient ��praticable�� encore et si le processeur est disponible il fonctionnerait.

Suivre des rapports indique la sortie de secours pour chaque entr�e dans l'�tat ��non praticable��.

Si le fil est mis pour dormir, alors le temps indiqu� devrait s'�couler.
Si le fil est suspendu, alors quelqu'un doit appeler la m�thode de r�sum� ().
Si le fil attend sur la variable de condition, quelqu'objet poss�de la variable devrait abandonner ceci en appelant annoncent () ou des m�thodes de notifyAll ().
Si le fil est bloqu� sur l'entr�e-sortie, alors la commande indiqu�e d'entr�e-sortie devrait devenir compl�te.

Mort
Un fil peut mourir de deux mani�res diff�rentes : l'un ou l'autre par une cause normale, ou �tant tu� (arr�t�). On dit qu'un fil meurt naturellement quand la m�thode de course () sort normalement. Cosider par exemple, la boucle de moment dans la m�thode de course est une boucle finie, il r�it�rera 100 fois et puis cesse l'ex�cution.

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

Nous pouvons �galement tuer un fil n'importe quand simplement en appelant la m�thode d'arr�t (). C'est suivant les indications du code ci-dessous :

public void run()
{
Thread myThread = new MyThreadClass();
myThread.start();
try
{
Thread.currentThread().sleep(10000);
} catch (InterruptedException e)
{
}
myThread.stop();
}

La m�thode de course ici cr�e et myThread de d�buts alors elle met le fil courant pour dormir pendant environ 10 secondes. Quand le fil courant se r�veille, la ligne audacieux dans le segment de code tuera le myThread.

La m�thode d'arr�t () jettera un objet de ThreadDeath pour tuer le fil. Quand le fil est tu� de cette mani�re il meurt asynchronously. Le fil mourra quand il re�oit r�ellement une exception de ThreadDeath.

IllegalThreadStateException
le syst�me d'ex�cution jette un IllegalThreadStateException quand nous appelons une m�thode dans un fil et l'�tat du fil ne tiendra pas compte de cet appel de m�thode. Par exemple, IllegalThreadStateException est jet� quand nous appelons une m�thode de suspension () dans un fil qui n'est pas ��praticable��.

Selon dans les exemples des fils �tudi�s jusqu'ici en ce chapitre, quand nous appelons une m�thode de fil qui peut jeter une exception, vous devriez attraper et manipuler l'exception, ou devriez d�clarer cela, l'exception appelante d'uncaught de jets de m�thode.

public void run()
{
Thread myThread = new MyThreadClass();
myThread.start();
try
{
Thread.currentThread().sleep(10000);
} catch (InterruptedException e)
{
}
myThread.stop();
}

() m�thode isAlive

Si la m�thode () les retours qu'isAlive vrais fil�tent alors est commenc�e et pas arr�t�e. Ainsi, si () la m�thode isAlive renvoie faux nous savons que le fil est l'un ou l'autre ��nouveau fil�� ou le ��mort��. Si () la m�thode isAlive renvoie vrai, vous alors le fil est ��praticable�� ou ��non praticable��.

Priorit� de fil

Quand un fil de Java est cr��, il h�rite de la priorit� du fil qui l'a cr��e. Nous pouvons �galement modifier la priorit� du fil n'importe quand apr�s sa cr�ation en utilisant le setPriority de m�thode (). Les priorit�s de fils s'�tendent de MIN_PRIORITY � MAX_PRIORITY (ce sont les constantes d�finies en fil de classe). � n'importe quel instant donn� de temps, quand les fils multiples sont pr�ts � s'ex�cuter, le syst�me d'ex�cution choisit le fil ��praticable�� ayant la priorit� la plus �lev�e pour l'ex�cution. Seulement quand ce fil s'arr�te, rapporte, ou devient ��non praticable�� pour une certaine sorte de raison, l'ex�cution faible priorit� de d�but de fil. S'il y a deux fils ayant la m�me unit� centrale de traitement de attente prioritaire, le programmateur les choisira d'une mode de rond-merle.

Fils de d�mon

N'importe quel fil de Java peut �tre fil de d�mon. Les fils de d�mon sont des fournisseurs de service pour ces fils ou objets fonctionnant dans le m�me processus que le fil de d�mon court. Par exemple, le navigateur de HotJava a un fil de d�mon, appel� le lecteur de fond d'image, qui lit les images du syst�me de fichiers ou le r�seau pour l'objet ou le fil l'un des qui a besoin d'une image.