Discussion :

[Neilime]

Bonjour,

je souhaite utiliser les threads pour tirer partie de plusieurs processeurs d'une machine pour faire des calculs.

Mais après mes différentes lectures, j'ai quelques questions bêtes :

1/ Si j'envoie à mes threads une référence vers mes données d'entrée, une arraylist d'objets, qui ne sera utilisée qu'en lecture, je n'aurais pas de problème de concurrence ?

2/ Puisqu'une méthode run() ne peut rien retourner, pour stocker des résultats, je dois transmettre à mon run une référence vers ma structure de données de sortie, que se passe-t-il si deux threads tentent d'ajouter en même temps un élément à ma structure de sortie ? (Pas de lecture, uniquement un ajout d'objet à la fin d'un thread)

3/ Si j'ai 1000 éléments dans ma structure de données d'entrée, je pourrais lancer 1000 threads en bouclant sur ma structure et en lançant un nouveau thread à chaque fois. MAis je me doute que ce n'est pas une bonne idée.
Si je veux limiter le nombre de thread à 4, y'a-t-il une méthode particulière pour attendre qu'un des 4 premiers threads soit terminé ? Puis-je mettre mes threads dans une arraylist et ne lancer les suivants que quand l'état d'un des thread est passé à l'état "mort" en parcourant sans cesse mon arraylist à la recherche d'un thread mort ?

Merci pour votre aide !

[adiGuba]

Salut,

1/ Si j'envoie à mes threads une référence vers mes données d'entrée, une arraylist d'objets, qui ne sera utilisée qu'en lecture, je n'aurais pas de problème de concurrence ?

Si tous les threads font uniquement de la lecture il n'y aura aucun problème... mais s'il y a ne serait-ce qu'un seul thread qui modifie cette liste tu pourrais te retrouver avec des comportements aléatoire.

Si la liste peut être modifié pendant son utilisation, il faut passer par une synchronisation.

2/ Puisqu'une méthode run() ne peut rien retourner, pour stocker des résultats, je dois transmettre à mon run une référence vers ma structure de données de sortie, que se passe-t-il si deux threads tentent d'ajouter en même temps un élément à ma structure de sortie ? (Pas de lecture, uniquement un ajout d'objet à la fin d'un thread)

Lorsqu'un thread modifie un objet non thread-safe, on peut se retrouver avec des comportements aléatoires. Il est donc nécessaire de synchroniser cela d'une manière ou d'une autre...

Tu peux aussi utiliser les Callables (qui retournent une valeur).

3/ Si j'ai 1000 éléments dans ma structure de données d'entrée, je pourrais lancer 1000 threads en bouclant sur ma structure et en lançant un nouveau thread à chaque fois. MAis je me doute que ce n'est pas une bonne idée.

En effet... La création de thread n'est réellement efficace que dans le cas où il y a suffisamment de coeur/processeur pour traiter ces tâches en parallèle.

Tu peux récupérer cette info très facilement avec la classe Runtime (voir plus bas).

Si je veux limiter le nombre de thread à 4, y'a-t-il une méthode particulière pour attendre qu'un des 4 premiers threads soit terminé ? Puis-je mettre mes threads dans une arraylist et ne lancer les suivants que quand l'état d'un des thread est passé à l'état "mort" en parcourant sans cesse mon arraylist à la recherche d'un thread mort ?

Tu peux utiliser les ExecutorServices qui simplifient l'utilisation des threads. Tu leurs soumets des tâches (Runnable ou Callable) qui seront exécutées dans des threads selon diverses conditions.

La classe Executors te permettant de créer divers types d'ExecutorService selon tes besoins, par exemple dans ton cas :

Code :

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

1
2
3
4
5
6
	// On récupère le nombre de coeurs/processeurs disponible :
	int maxThreads = Runtime.getRuntime().availableProcessors();
 
	// On crée un executor qui utilisera autant de thread qu'il y a de processeur :
	// Si on lui soumet plus de tâche elles seront mises en attente
	ExecutorService executor = Executors.newFixedThreadPool( maxThreads );

Le package java.util.concurrent contient plein d'outils pour la gestion des threads et de la concurrence...

N'hésite pas à détailler ton objectif exact pour plus de précision


a++

[tchize_]

1/ aucun
2/ oui, des problème. Regarde plutot du cote des Callable et des Executor
3/ Un ExecutorService avec un nombre fixé de thread serait une bonne approche http://download.oracle.com/javase/6/...orService.html

[Neilime]

Z'êtes trop forts, je reviens vite en cas de problèmes !

Merci !

[rolfone]

je viens de faire 2 3 test avec un panel de 100 thread qui cherche les nombre 1er de 2 a 10 000 et voila :

- si je lance 100 thread en parallèle il me faut 13 s pour que tout les thread est fini et un temps moyen = 7s , temps min = 1,2s , temps max = 12s

- si je lance 1 thread par processeur il me faut 13 s pour que tout les thread est fin et temps moyen = 259ms , temps min = 203ms , temps max = 328 ms

il faut donc voir ce que l'on veux faire.

ExecutorService simplifie pas mal la vie pour le séquencement des taches

ps : mon test ne porte peut être pas sur asse de Thread

[Neilime]

Bonjour tout le monde,

j'ai un problème de conception avec les Callables que vous m'avez judicieusement proposé plus haut.

Mon calcul que je découpe en plusieurs parties, nécessite :
- une grosse structure de données (qui ne varie pas et sera uniquement lue)
- et un Integer (qui varie disons de 1 à 1000),
Ces deux éléments devant être envoyés à ma classe UniteCalcul qui implémente Callable.

Je découvre que call() ne peut prendre aucun paramètre, tout doit donc passer dans le constructeur de ma classe UniteCalcul qui implémente Callable.

Moi qui pensais pouvoir me contenter d'une instance de UniteCalcul dont j'appellerai la fonction call() 1000 fois en lui fournissant un nouvel Integer à chaque fois, je suis en train de comprendre que je dois forcément passer mon Integer au constructeur ce qui implique de créer 1000 instances de UniteCalcul en lui envoyant à chaque fois ma grosse structure de données et mon Integer.

D'où ma question, ultra de base, quand dans mon constructeur, j'assignerai ma structure de données reçue à ma variable de classe chargée de la recevoir (this.maStructureDeDonnees = structureDeDonneesRecue), y'aura-t-il copie des données ou juste de la référence ?

(Pour éviter de recopier 1000 fois ma grosse structure de données donc)

Merci de m'avoir lu !

Edit : Correction phrase incompréhensible

[tchize_]

tous les objet java sont manipulé par leur référence, il n'y aura copie que de la référence.

Pour avoir une copie de l'objet avec son contenu (duplication donc) il faudrait utiliser sa méthode clone(). Donc

Code :

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

1
2
3
MonObject o = unAutreObjet; // occupation d'une référence, soit approximativement 64 bits
 
MonObject o = unAutreObjet.clone() // ducplication, peux occuper beaucoup de mémoire