Discussion :

[ToTo13]

Bonjour,

suite à quelques soucis avec ma propre classe de gestion des threads, j'ai décidé d'utiliser un ThreadPoolExecutor avec une SynchronousQueue.

Voilà exactement ce que je veux faire :
- je veux disposer de N threads, ni plus ni moins.
- je ne veux surtout pas que ces threads soient détruits après utilisation car ils vont être réutilisés de nombreuses fois.
- je veux pouvoir passer des paramètres pour les calculs.

Voici ma classe qui étend la classe Thread qui effectue les calculs :

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
 
private class MaClasseThread extends Thread
{
 
private int number = -1 ;
 
public MaClasseThread(int number)
	{
	super() ;
	this.number = number ; // Numéro unique (bien évidemment).
	}
 
public void Parameters(Object... parameters)
	{
	// ... on récupère les paramètres
	}
 
public void run()
	{
	// ... on fait la travail ici en fonction des paramètres
	}
}

Je construits ma synchronous queue et mon ThreadPoolExecutor :

Code java :

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

1
2
3
4
5
6
 
	BlockingQueue<Runnable> queue = new SynchronousQueue<Runnable>() ;
	for (int i=0 ; i < N ; i++)
		queue.add(new MaClasseThread(i)) ;
 
	ThreadPoolExecutor tpe = new ThreadPoolExecutor(N, N, ?, TimeUnit.MILLISECONDS, queue) ;

J'ai mis un '?' car je ne sais pas quoi mettre car je veux les garder vivant indéfiniment.

Questions :
- comment récupérer le premier thread libre ?
- comment lui passer le travail que je souhaite ?
- comment le lancer après passage des paramètre de calcul ?


Merci par avance

[professeur shadoko]

pas la peine de se pose la question du premier Thread libre.
pour les tâches voir la doc de ExecutorService

[thelvin]

Je sais pas trop pourquoi tu t'amuses à créer tes threads, et qu'est-ce que tu essaies de faire en les mettant dans la queue.
Les threads, c'est le boulot du ThreadPoolExecutor. Oublie-les.

BJ'ai mis un '?' car je ne sais pas quoi mettre car je veux les garder vivant indéfiniment.

Ce que tu veux. Ce sera ignoré, puisque le max et le core sont égaux, donc il n'y aura jamais plus de threads que le core, et donc jamais aucun candidat à l'arrêt.

[ToTo13]

pas la peine de se pose la question du premier Thread libre.
pour les tâches voir la doc de ExecutorService

Ben... comment est ce que je le récupère ?

Je sais pas trop pourquoi tu t'amuses à créer tes threads, et qu'est-ce que tu essaies de faire en les mettant dans la queue.
Les threads, c'est le boulot du ThreadPoolExecutor. Oublie-les.

Ok.
Donc je les passe directement au ThreadPoolExecutor. Mais avec quelle méthode ? submit, newTaskFor ?

Ce que tu veux. Ce sera ignoré, puisque le max et le core sont égaux, donc il n'y aura jamais plus de threads que le core, et donc jamais aucun candidat à l'arrêt.

Ok merci.

[thelvin]

Donc je les passe directement au ThreadPoolExecutor. Mais avec quelle méthode ? submit, newTaskFor ?

Tu sais, newTaskFor() est protected. Ce n'est pas franchement ce qu'on attendrait d'un moyen de soumettre une tâche à l'ExecutorService.
D'ailleurs, la JavaDoc indique à quoi ça sert : en gros encapsuler un Runnable ou un Callable dans un objet tâche gérable par l'ExecutorService.

submit(), donc.

[ToTo13]

Tu sais, newTaskFor() est protected. Ce n'est pas franchement ce qu'on attendrait d'un moyen de soumettre une tâche à l'ExecutorService.
D'ailleurs, la JavaDoc indique à quoi ça sert : en gros encapsuler un Runnable ou un Callable dans un objet tâche gérable par l'ExecutorService.

submit(), donc.

Effectivement, je n'avais pas vu le protected. Merci.

Je soumets donc mes classes runnable grâce à cette méthode.
Je vois donc comment lancer des tâches via le ThreadPoolExecutor comme cela est fait ici.
Mais à chaque itération, on crée un nouveau thread que l'on donne au ThreadPoolExecutor. Or ce que je voudrai c'est éviter de ré-allouer à chaque itération, donc j'ai besoin de pouvoir passer les paramètres à mon thread avant de le donner au ThreadPoolExecutor.

[professeur shadoko]

à chaque boucle tu crée un Callable qui est pris en charge par un Thread qui se libère dans le pool. tu ne crée pas un nouveau Thread (le nombre de Thread dépend de la stratégie de l'executor que tu as choisi)