Discussion :

[ToTo13]

Bonjour,

je fais une recherche exhaustive (calcul de toutes les combinaisons possibles). Mais pour accélérer le processus, je lance plusieurs threads (autant que de CPU) et je dois donc synchroniser le travail de mes différents threads.

voici ma recherche exhaustive (classique) :

Code java :

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
 
private List<Integer> threadsfree = new Vector<Integer>() ;
 
private void Compute(int column)
	{
	if ( "bas/feuille de l'arbre de recherche, donc on travaille" )
		{
		int free = getFreeThread() ; // On attend un thread libre (appel bloquant).
 
		synchronized ( threads[free].lock ) // On synchronise le verrou.
			{
			threads[free].Work(mywork) ; // On donne le travail
			threads[free].lock.notify() ; // On lance le thread.
			}
 
		return ;
		}
	...
	}

Pour faire cela, j'ai donc une méthode qui s'occupe d'attendre qu'un thread soit libre :

Code java :

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
 
private synchronized int getFreeThread()
	{
	while ( threadsfree.isEmpty() ) // On attend qu'un thread soit libre.
		try	{
			wait() ;
			}
		catch ( InterruptedException e )
			{
			e.printStackTrace() ;
			}
 
	int free ;
	synchronized ( threadsfree )
		{
		free = threadsfree.get(0) ; // On récupère le numéro du thread libre
		threadsfree.remove(0) ; // On supprime le thread de la liste.
		}
	// J'ai testé, ici le thread "free" n'est plus dans la liste et il n'y a pas de doublon.
	return free ;
	}

Et voici le thread qui fait le travail demandé :

Code java :

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
35
36
37
38
39
40
41
42
 
private class SysResThread extends Thread
{
 
private int number = -1 ;
 
public Object lock = new Object() ;
 
 
 
public SysResThread(SystematicResearch parent, int number)
	{
	super() ;
	this.parent = parent ;
	this.number = number ; // Numéro unique (bien évidemment).
	}
 
 
public void run()
	{
	while ( true ) // On boucle pour garder le thread actif.
		{
		synchronized ( lock )
			{
			try {
				parent.addFreeThread(number) ; // On a finit (ou pas commencé), donc on signale que l'on est libre.
 
				lock.wait() ; // On attend du boulot. Seul le parent libère le thread.
				// On arrive ici que si le thread a été libre et a été libéré par la classe mère/parent.
				// Souci... le thread est toujours dans la liste des threads libres :-(
				}
			catch ( InterruptedException e )
				{
				e.printStackTrace() ;
				}
			}
 
		// ... on fait la travail ici.
		}
	}
 
}

Mais tout ceci ne fonctionne pas :-(
Dans la classe/thread, je m'aperçois qu'après que le thread ait été libéré par la classe parent, il apparaît toujours dans la liste des threads libres :-(

Il me semble avoir tout synchronisé comme il se doit, attendre les threads, etc.
Mais pourquoi diable est ce que parfois un thread apparaît toujours dans la liste des threads libres ?

Est ce que quelqu'un aurait une idée ?
Merci par avance...

[Gardyen]

tu ne veux pas utiliser l'api java.util.concurrent, le Semaphore plus exactement ?

[thelvin]

En fait, ce genre de constructions est typiquement le boulot de ThreadPoolExecutor.

Quant à savoir pourquoi ça marche pas comme ça, pfff, il y a trop de synchronized sur trop de trucs différents.
Il y a une ressource partagée, une seule : un ensemble de threads libres pour travailler. Il faut synchroniser ça et rien d'autre.
(Éventuellement il peut y avoir besoin de synchroniser un "gestionnaire des résultats.")

[ToTo13]

tu ne veux pas utiliser l'api java.util.concurrent, le Semaphore plus exactement ?

J'ai essayé mais sans meilleurs résultats :-(
De plus sur tous les cours disponibles dans le forum, il est dit que ce que je fais est équivalent.

[Gardyen]

comme indiqué par thelvin, le ThreadPoolExecutor correspond à ce que tu veux réaliser, en particulier le Executors.newFixedThreadPool(int).

[ToTo13]

Au détail près que j'ai l'impression que le ThreadPoolExecutor lance un nouveau thread par nouvelle tâche.
Dans mon cas, je ne tue jamais un thread, je souhaite le débloquer pour qu'il réalise une tâche, puis qu'il se bloque jusqu'à ce qu'on lui affecte une nouvelle tâche.
Ce qui explique la bouche While bloquante dans le méthode Run() de mon thread.

[Gardyen]

d'où le fixedThreadPool, cf la doc:

Creates a thread pool that reuses a fixed number of threads operating off a shared unbounded queue.

[thelvin]

Au détail près que j'ai l'impression que le ThreadPoolExecutor lance un nouveau thread par nouvelle tâche.

Euh, un ThreadPoolExecutor s'arrange donc pour ne pas utiliser de pool. Logique.

[ToTo13]

d'où le fixedThreadPool, cf la doc:

Ok je vais regarder.

[ToTo13]

Je ne sais pour quelle raison obscure, mon code marche parfaitement : plus aucune erreur !
Je n'arrivais pas à comprendre l'erreur et du coup j'ai remis exactement le code d'origine (récupération dans un backup). Après un redémarrage, tout fonctionne à nouveau :s.

Je vais toutefois essayer de faire fonctionner cela avec les classes dédiées.

[ToTo13]

J'ai finalement utilisé une BlockingQueue pour remplacer la liste que j'avais et cela fait très bien le travail. Cela pourra peut être intéressé quelqu'un.

Code java :

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

BlockingQueue<SysResThread> threadsfree = new ArrayBlockingQueue<SysResThread>(nbCPU) ;