10. PROGRAMMATION PARALLELE
AVEC LES THREADS
 
 
Précédent Suivant
 
Programmation parallèle
avec les threads
Programme parallèle
* Parfois, un programme = plusieurs séquences d'exécution en parallèle
* Quel est l'intérêt ?
* Sur multi-processeur: démultiplier la puissance de calcul
* Partage de l'exécution d'un calcul entre plusieurs processeurs
* Sur mono-processeur: inhérent au fonctionnement / éviter un blocage
* Interface graphique + processus de calcul
* Parallélisation par les "processus"
* Processus = séquence d'exécution
* Duplication de la mémoire du programme pour chaque processus
* Parallélisation par les "threads"
* Thread = séquence d'exécution
* Mémoire du programme partagée entre tous les threads
* Seul l'empilement des contextes est différent
* Comparaison
* Un thread est plus léger qu'un processus
* Mais les threads doivent partager des données
Threads en Java (1/3)
* En Java, un thread est modélisé par deux objets
* 1er objet = portion de code à exécuter en parallèle
* Un objet implémente l'interface "Runnable"
* Le code du thread se trouve dans sa méthode "run"
* 2nd objet = contrôle du thread
* Un objet de la classe "Thread"
* Ces deux objets peuvent être regroupés en un seul
* Car "Thread" implémente l'interface "Runnable"
Threads en Java (2/3)
* Création d'un objet "Runnable"
* class MonRunnable implements Runnable {
public void run() { ... }
}
* Création d'un thread attaché à l'objet "Runnable"
* MonRunnable code = new MonRunnable();
* Thread thread = new Thread(code);
* Démarrage de l'exécution parallèle du thread
* thread.start();
* Comment arrêter un thread ?
* Eviter d'utiliser les méthodes d'interruption "stop" et "interrupt"
* Provoquent des incohérences au niveau des données
* Un thread s'arrête lorsqu'il n'a plus rien à exécuter
* Donc, prévoir dans le code un mécanisme d'arrêt
* Penser à détruire le thread par l'intermédiaire du garbage collector
* thread = null;
Threads en Java (3/3)
class Horloge implements Runnable {
protected boolean fin;
public Horloge() { ... }
public void afficher() { ... }
public void stop() { fin = true; }
public void run() {
fin = false;
while (!fin) {
afficher();
try { Thread.sleep(1000); }
catch(Exception e) {}
}
}
}
...
Horloge h = new Horloge();
Thread t = new Thread(h);
t.start();
...
h.stop();
Partage de ressources (1/3)
* Exécution parallèle de threads ==> partage de zones mémoire
* Protection de la mémoire partagée
* Accès par des méthodes "synchronisées"
* Mot-clé "synchronized" devant ces méthodes
* Méthode synchronisée ==> accès par un seul thread à la fois
* Protection par "jeton"
* Pour chaque objet, un jeton contrôle l'accès
* L'accès à une méthode synchronisée nécessite le jeton
* Un autre thread qui accède à la méthode synchronisée attend le jeton
* Une fois la méthode synchronisée terminée, le jeton est rendu
* Accès unique à toutes les méthodes synchronisées d'un objet
* Un seul jeton contrôle l'accès à toutes les méthodes synchronisées
* Permet ainsi une protection de tous les attributs d'un objet
* Protection séparée pour chaque objet
* Accès à une méthode synchronisée par des objets différents autorisé
Partage de ressources (2/3)
* Exemple: réservation d'un ticket
* Réserver un ticket, en donnant son nom
public synchronized int reserveTicket(String nom) {
if (n >= N) return -1;
ticket[n] = nom;
return n++;
}
* Retrouver le ticket d'une personne à partir de son nom
public synchronized int numeroTicket(String nom) {
int i = 0;
while (i < n && !ticket[i].equals(nom)) ++i;
if (i == n) return -1;
return i;
}
* Une méthode modifie un attribut, l'autre le consulte
* Sans synchronisation ==> incohérence des données
Partage de ressources (3/3)
* Contrôler plus finement le partage de ressources
* Exemple: le sémaphore
public synchronized void prendreRessource() {
while (n == 0) {
try { this.wait(); }
catch (Exception e) {}
}
--n;
}
public synchronized void rendreRessource() {
++n;
this.notify();
}
* wait(): rend le jeton de l'objet et attend d'être débloqué
* notify(): réactive les threads bloqués
* "wait" et "notify" sont des méthodes de la classe "Object"
 
 
Copyright (c) 1999-2016 - Bruno Bachelet - bruno@nawouak.net - http://www.nawouak.net
La permission est accordée de copier, distribuer et/ou modifier ce document sous les termes de la licence GNU Free Documentation License, Version 1.1 ou toute version ultérieure publiée par la fondation Free Software Foundation. Voir cette licence pour plus de détails (http://www.gnu.org).