<<<M1 - UE2

1 Rappels programmation concurrente et threads

Note : on pourra se référer à l'API JavaSE 7 pour plus de détails.

1.1. Thread

En informatique, un thread d'exécution (ou plus simplement thread) est la plus petite partie qui peut être traitée par un système d'exploitation lors de l'exécution. L'une des fonctionnalités de l'OS (Operating System) consiste à réaliser l'ordonnancement des processus à exécuter.

On qualifie généralement un thread de processus léger car il est contenu dans un processus.

Un processus (ou plus simplement programme en exécution) peut également être composé de plusieurs threads qui s'exécutent de manière concurrente. Les threads d'un même processus partagent des ressources (comme de la mémoire ou des canaux d'entrée / sortie).

Lorsque l'on programme avec Java, la gestion des threads est simplifiée : un programme, c'est à dire une classe dotée de la méthode main, possède un thread d'exécution.

1.1.1. Exemple fork en C

La commande top indique bien deux processus.

3129 richer    20   0  1988   60    0 R   22  0.0   0:01.58 forkit.exe
3128 richer    20   0  1988  284  228 R   21  0.0   0:01.54 forkit.exe

1.1.2. création d'un thread

Pour créer d'autres threads au sein du programme principal, on définit des classes qui vont :

• soit hériter de la classe java.lang.Thread
• soit implémenter l'interface java.lang.Runnable

Dans les deux cas, il faudra définir la méthode run qui contient les instructions exécutées par le thread.

class MyRunnable extends MyClass implements Runnable {
	public void run() {
		// code to execute
	}
}

class MyThread extends Thread {
	public void run() {
		// code to execute
	}
}

Un thread peut être doté d'un nom (constructeur ou setName()) et/ou rattaché à une groupe de threads (ThreadGroup - cf plus loin dans le cours).

class MyThread extends Thread {

	public MyThread(String name) {
		super(name);
	}
	
	public void run() {
		while (true) {
			System.err.println("hello world !");
		}
	}
}

1.1.3. lancement de l'exécution d'un thread

On lance l'exécution du thread par appel de ma méthode start

class MyProgram {

	public static void main(String args[]) {
		MyThread thread = new MyThread("a thread");
		thread.start();
	}
	
}

ou encore :

class MyProgram {

	public static void main(String args[]) {
		new Thread(new MyRunnable()).start();
	}
	
}

Le programme ne terminera que lorsque le thread aura terminé son exécution.

Voici un exemple :

La commande top indique un seul processus.

 3843 richer    20   0 1223m  31m 7336 S   59  0.4   0:04.51 java

1.1.4. états d'un thread

• après création le thread se trouve dans l'état new
• puis passe dans l'état runnable après appel à la méthode start
• l'ordonnanceur (scheduler) choisit le prochain thread à exécuter et le passe dans l'état running, puis le repassera dans l'état runnable
• le thread peut appeler la méthode yield() pour signigier à l'ordonnanceur qu'il désire revenir à l'état runnable pour laisser les autres threads s'exécuter

On peut connaître l'état d'un thread en appelant la méthode Thread.State getState().

1.1.5. suspendre et reprendre l'exécution d'un thread

Il existe plusieurs moyens pour suspendre temporairement l'exécution d'un thread.

• la méthode static void sleep(long millis) force le thread à suspendre son exécution pendant un temps exprimé en milli secondes.
• la méthode void wait() associée à la classe Object force le thread à suspendre son exécution jusqu'à ce qu'un autre thread appelle la méthode void notify() ou notifyAll()
• la méthode void wait(long timeout) possède le même comportement que la méthode précédente mais permet de reprendre l'exécution si la notification n'a pas été déclenchée après un certain laps de temps.

1.1.6. synchronisation des threads

Il existe plusieurs niveaux de synchronisation pour les threads.

• on peut utiliser le mot clé synchronized devant un nom de méthode, ce qui permet de poser un verrou sur la méthode, elle ne sera exécutée que par un seul thread à la fois.
  Warning: file_get_contents(ens/m1/info/ue2/BankAccount.java): Failed to open stream: No such file or directory in /home/jeanmichel.richer/public_html/html_business.php on line 448
  
  1.  
• on peut utiliser le mot clé synchronized à l'intérieur d'une méthode pour établir une exclusion mutuelle sur des données à modifier :
  Warning: file_get_contents(ens/m1/info/ue2/BankAccount2.java): Failed to open stream: No such file or directory in /home/jeanmichel.richer/public_html/html_business.php on line 448
  
  1.  
• on peut utiliser la méthode void join() qui permet d'attendre la fin de l'exécution d'autres threads avant de poursuivre un traitement

Le résultat de l'exécution est par exemple :

thread0:1
thread1:1
thread2:1
thread1:2
thread0:2
thread2:2
thread2:3
thread1:3
thread2:4
thread0:3
thread1:4
thread0:4
JOIN HERE

1.1.7. priorités d'un thread

Chaque thread possède une priorité d'exécution, héritée par défaut de son thread parent. On peut cependant modifier la priorité d'un thread grâce à void setPriority(int newPriority). Celle-ci varie entre :

• Thread.MIN_PRIORITY = 1
• Thread.NORM_PRIORITY = 5
• Thread.MAX_PRIORITY = 10

On obtient la priorité d'un thread grâce à int getPriority().

1.1.8. groupes de threads

Il est parfois intéressant de regrouper les threads par groupes. Sur l'exemple suivant on crée deux groupes de threads, le groupe g1 continuera à s'exécuter alors que g2 sera interrompu par le thread t3. Une exception InterruptedException est levée car les threads de g2 sont interrompus alors qu'ils sont dans l'état waiting engendré par l'instruction sleep

Le résultat de l'exécution est par exemple :

g1.t1-1 running
g1.t1-4 running
g2.t2-1 running
g1.t1-3 running
g2.t2-2 running
g2.t2-4 running
g1.t1-2 running
g2.t2-3 running
g1.t1-1 running
g1.t1-4 running
g1.t1-3 running
g2.t2-1 running
g2.t2-4 running
g1.t1-2 running
g2.t2-2 running
g2.t3:active = 0
g2.t2-3 running
g2.t2-1:java.lang.InterruptedException: sleep interrupted
g2.t2-4:java.lang.InterruptedException: sleep interrupted
g2.t2-3:java.lang.InterruptedException: sleep interrupted
g2.t2-2:java.lang.InterruptedException: sleep interrupted
g1.t1-1 running
g1.t1-4 running
g1.t1-3 running
g1.t1-2 running

1.2. Programmation concurrente

Le principe de la programmation concurrente consiste à faire interagir plusieurs threads pour accomplir une tâche.

On peut distinguer deux approches :

• calculs indépendants : on répartit la charge de travail sur plusieurs threads (simple)
• calculs coopératifs : les threads coopèrent pour accomplir la tâche (complexe)

Exemple 1 : on désire réaliser le calcul de la somme des évaluations d'une fonction f(x), pour différentes valeurs de x, sur l'intervalle [x₁, x₂] mais le calcul de f(x) prend du temps. Les calculs étant indépendants on décide de multithreader l'application. On utilisera par exemple k threads qui se répartiront la tâche : feront les calculs en parallèle et reporteront leurs résultats à l'application principale.

Exemple 2 : on souhaite résoudre un problème d'optimisation combinatoire et on crée plusieurs threads qui recherchent la meilleure solution possible et échangent de l'information : exploration, intensification.