« Programmation Java/Processus légers et synchronisation » : différence entre les versions
Contenu supprimé Contenu ajouté
m Programmation Java Threads et synchronisation déplacé vers Programmation Java Processus légers et synchronisation: francisation |
francisation |
||
Ligne 1 :
{{Programmation Java}}
Les processus légers ''(threads)'', ou fils d'exécution, permettent l'exécution de plusieurs tâches en même temps.
== Qu'est ce qu'un
Un thread est un contexte d'exécution d'une application.▼
Ce thread possède sa propre pile et pointeur d'exécution.▼
Une application en cours d'exécution (un processus) peut avoir plusieurs threads.▼
Tous les threads d'un même processus partage la même zone de données.▼
Ce qui veut dire que toute variable membre d'une classe est modifiable par n'importe quel thread.▼
Il faut donc un moyen de synchroniser l'accès aux variables (voir paragraphe "Synchronisation").▼
▲Une application en cours d'exécution (un processus) peut avoir plusieurs
Par défaut, une application possède un seul thread, créé par le système.▼
Cependant, en Java, d'autres threads sont créés quand l'application utilise une interface graphique, notamment un thread gérant la boucle de lecture des messages systèmes.▼
▲Ce qui veut dire que toute variable membre d'une classe est modifiable par n'importe quel
▲Il faut donc un moyen de synchroniser l'accès aux variables (voir paragraphe
== Thread courant ==▼
▲Cependant, en Java, d'autres
En Java, tout thread est représenté par un objet de classe <code>Thread</code>.▼
Le thread courant est retourné par la méthode statique <code>currentThread</code> de la classe <code>Thread</code>.▼
La classe <code>Thread</code> possède quelques méthodes statiques agissant sur le thread courant :▼
* la méthode <code>sleep(long millis)</code> permet de suspendre le thread durant le temps donné en millisecondes;▼
* la méthode <code>interrupted()</code> teste si le thread courant a été interrompu;▼
* la méthode <code>dumpStack()</code> affiche la pile d'appel du thread courant (debuggage).▼
▲Le
▲La classe <code>Thread</code> possède quelques méthodes statiques agissant sur le
== Créer un thread ==▼
▲* la méthode <code>sleep(long millis)</code> permet de suspendre le
La classe <code>Thread</code> peut être dérivée pour créer un autre thread.▼
▲* la méthode <code>interrupted()</code> teste si le
▲* la méthode <code>dumpStack()</code> affiche la pile d'appel du
Dans ce cas, il faut surcharger la méthode <code>run()</code> pour y mettre le code exécuté par le processus léger.
Exemple :
Ligne 35 ⟶ 38 :
public void run()
{
System.out.println("Un nouveau
Thread.sleep(1000); // suspendu pendant 1 seconde
System.out.println("Fin du nouveau
}
}
Il est alors créé et démarré de la manière suivante :
MyThread myth=new MyThread();
System.err.println("Démarrer le
myth.start();
System.err.println("Le
Il n'est pas toujours possible d'étendre la classe <code>Thread</code> car Java n'autorise qu'une classe de base.
Mais il est permis d'
L'interface <code>Runnable</code> permet de résoudre le problème.
Ligne 58 ⟶ 61 :
public void run()
{
System.out.println("Un nouveau
Thread.sleep(1000); // suspendu pendant 1 seconde
System.out.println("Fin du nouveau
}
}
Le
MyClass myclass=new MyClass ();
Thread th=new Thread(myclass); // <--
System.err.println("Démarrer le
th.start();
System.err.println("Le
== Actions sur un
=== Cycle de vie d'un
Un
* état ''
* état ''
* état ''
* état ''terminé'' : le processus a achevé son exécution ou a été interrompu.
=== InterruptedException ===
Cette classe d'exception est lancée par les méthodes de la classe <code>Thread</code> et celle de la classe <code>Object</code> demandant la suspension pour un temps indéterminé du thread courant (attente en général).▼
▲Cette classe d'exception est lancée par les méthodes de la classe <code>Thread</code> et celle de la classe <code>Object</code> demandant la suspension pour un temps indéterminé du
Cette exception est lancée quand le thread en attente est interrompu.▼
Capturer cette exception permet d'interrompre l'attente, et libérer des ressources pour terminer proprement.
=== Attendre la fin d'un
La méthode <code>join()</code> de la classe <code>Thread</code> peut être appelée pour attendre la fin d'un
Exemple :
th.wait(); // InterruptedException à capturer
=== Interrompre un
Cette méthode provoque le lancement d'une exception de type <code>InterruptedException</code> quand le processus appelle une méthode d'attente.
== Synchronisation ==
La synchronisation devient nécessaire quand plusieurs
=== mot-clé synchronized ===
Le mot-clé <code>synchronized</code> permet un accès exclusif à un objet.
Ligne 107 ⟶ 116 :
}
''... code non protégé ...''
Le code protégé n'est exécuté que par un seul
Durant l'exécution de ce code protégé par un
Le mot-clé <code>synchronized</code> peut également être utilisé dans la déclaration des méthodes :
Ligne 140 ⟶ 149 :
=== Attente et signal ===
Quand le mot-clé <code>synchronized</code> ne suffit pas (par exemple, permettre l'accès à deux threads simultanément au lieu d'un seul), il est possible de suspendre un
La classe <code>Object</code> possède les méthodes suivantes :
* <code>wait()</code> suspend le
* <code>wait(long timeout)</code> suspend le
* <code>notify()</code> réveille l'un des
* <code>notifyAll()</code> réveille tous les
Pour appeler l'une de ces quatre méthodes, il faut ''posséder'' l'objet.
| |||