Discussion :

[Opsse]

Bonjour,

Je suis face à un problème de multithread et j'aurais besoin d'un coup de main pour trouver une solution.

Mon système actuel :

J'ai un main qui exécute plusieurs threads d'après une liste de tache. La liste de tache étant très longue je limite le nombre de thread simultané grâce à un compteur que j'incrémente quand un thread est lancé et que je décrémente lorsqu'il se termine. Lorsque la limite du nombre de thread est atteinte je met le main en attente sur une variable de condition. Un signal est lancé à chaque fois qu'un thread se termine.

Voici le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
for (Page page : pages)
{
	synchronized(this.threadMonitor)
	{
		while(this.nbThread >= this.settings.getMaxThread())
		{
			try
			{
				this.threadMonitor.wait();
			}
			catch (InterruptedException e)
			{System.err.println("InterruptedException - threadMonitor.wait");}
		}
 
		this.nbThread++;
 
		threadPages[count] = new ThreadElement(page);
		threadPages[count].start();
 
		count++;
	}
}
 
for (ThreadElement thread : threadPages)
{
	try
	{
		thread.join();
	}
	catch (InterruptedException e)
	{
		e.printStackTrace();
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public void decremNbThread()
{
	synchronized (this.threadMonitor)
	{
		this.nbThread--;
 
		this.threadMonitor.notify();
	}
}

Ceci fonctionne bien mais je voudrais aller plus loin.

Mon problème :

Je veux que chaque thread ainsi créé puisse lui aussi créer des threads d'après une sous liste de tache tout en conservant la limite totale de thread.
Mais d'après moi un tel système peut être bloquant car chaque thread peut attendre une place pour exécuter une sous tache mais sans libérer sa place.
Ma première idée est de compter un thread en attente comme ne faisant pas partie du compte, si un thread veut lancer ses fils il commencer par décrémenter le compteur. Mais j'ai peur que le nombre de thread en attente s'envole.


Mes questions :

Existe il une façon de résoudre le problème que j'ai énoncé ?
Dans le main, le fait que beaucoup de threads soit en attente du join est il un problème ? (plusieurs milliers)
Si je veux que les sous-taches se fassent en priorité, la méthode Thread.setPriority peut elle m'aider ? Comment ?


Ça fait beaucoup de question en suspend, j'espère que quelqu'un saura me répondre

[eulbobo]

Tu essayes de réinventer la roue !
Mais c'est une bonne chose, ça veut dire que tu as des idées.

Ce dont tu as besoin se trouve dans la classe Executors qui permet de créer des Pools de Threads réutilisables, dont certains pools ont une taille limitée (FixedThreadPool).
Ces objets permettront de gérer la création/utilisation de threads.

Je te laisse donc regarder/chercher tout ce qui se fait avec les ThreadPools et les Executors
En gros, ça se passe comme ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
Runnable r = new MyRunnable();
Executor ex = Executors.newCachedThreadExecutor();
ex.execute(r);
...
ex.shutdown(); // quand tu as fini
...
if (!ex.isTerminated(){
    List<Runnable> executionsPasTerminees = ex.shutdownNom(); // si ça ne veut pas finir
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
for (ThreadElement thread : threadPages)
{
	try
	{
		thread.join();
	}
	catch (InterruptedException e)
	{
		e.printStackTrace();
	}
}

Dans cette boucle, tu dis grosso modo : attends jusqu'à ce que tous les threads soient terminés. C'est bien ce que tu veux faire?
Au niveau impacts, y'a pas de problème si c'est ce que tu veux effectivement faire, mais ça peut être long s'il y en a beaucoup !

Si je veux que les sous-taches se fassent en priorité, la méthode Thread.setPriority peut elle m'aider ? Comment ?

En théorie oui, mais en pratique, tu n'as aucune façon de savoir si la JVM que tu utilise va respecter ce que tu lui demandes. (a savoir, passer en priorité l'exécution d'un nouveau Thread à niveau de priorité plus important plutôt que de finir celui qui est en cours)
Si tu veux être sûr de l'ordre, il faudrait stocker tes Threads dans une PriorityQueue (file qui permet de classer les éléments par priorité en fonction de leur ordre compareTo) qui est consommée par ton "moteur" : chaque fois que ton moteur va vouloir lancer un Thread, il les prendra dans l'ordre que TU as spécifié.
Pour ne pas surcharger la queue de Threads, il faut préciser une taille de queue max dans le constructeur de ta PriorityQueue et ajouter des éléments à la file en utilisant la méthode offer() (qui renvoie true si tu as pu ajouter l'élément, sinon à toi d'attendre et de boucler jusqu'à ce que la méthode te renvoie 'true')

Sinon, tu peux aussi passer par une LinkedTransferQueue qui ajoute la méthode offer() qui attend tout seul qu'il y ait de la place (mais ça ne sera pas classé :/)

[joel.drigo]

+1 pour les ExecutorService.

J'utiliserais un awaitTermination( de faire le shutdown() (sinon, les sous-tâches qui ne pourraient ne pas avoir encore été lancées seront rejetées).

[Opsse]

J'apprends toujours beaucoup de choses utiles quand je poste sur ce forum, merci pour les réponses et la réactivité.

Je vais me documenter sur les FixedThreadPool ca semble effectivement être une bonne idée, merci.

[Logan Mauzaize]

Pour donner priorité aux sous-tâches tu peux regarder du côté de Fork/Join.

Pour savoir si tu as terminées tes tâches, tu peux utiliser :

• un (dé-)compteur : CountDownLatch
• une "poison pill"

[Opsse]

Voici ce que j'obtiens en suivant vos conseils. C'est basiquement les mêmes mécaniques que ce que j'avais mis en place mais en plus propre et performant.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
this.executor = Executors.newFixedThreadPool(this.settings.getMaxThread());
this.doneSignal =  new CountDownLatch(this.pages.size());
 
for (Page page : pages)
{
	this.executor.execute(new ThreadElement(page, this.doneSignal));
}
 
try
{
	this.doneSignal.await();
}
catch (InterruptedException e)
{
	e.printStackTrace();
}
 
this.executor.shutdown();

Je n'utilise pas encore les sous-taches mais je sens que ca va poser problème étant donné que le CountDownLatch demande le nombre total de tache alors que je ne connais pas à l'avance le nombre de sous-taches de chaque tache.

[Logan Mauzaize]

Tu peux également regarder le framework Fork/Join, il dispose d'une API qui simplifie la gestion des sous-tâches.

De cette manière tu pourras également faire un invokeAll à la place du CountDownLatch