tâches en parallèle [Timer]

Bonjour
Je voudrai traiter des entiers (int) d'un tableau en parallèle.
Est ce que quelqu'un a une idée comment le faire avec les "Timer" ?

Merci d'avance ;)

Thread tu veux surement dire?

Oui exactement :)

La question que je me pose c'est pourquoi veux-tu paralléliser ton traitement ?
Si c'est pour obtenir de meilleur performance je suis pas sur que ce soit la bonne solution (en Java en tout cas) :

• si ton processeur possède un seul cœur, tu ne gagneras rien, au contraire ;
• si ton processeur en possède plusieurs, tu peux toujours essayer (en créant un thread pour chaque cœur et en découpant ton tableau en N partie, N étant le nombre de coeur) mais ce topic me fait penser que ça pourrait même être pire ; mais tu peux toujours tester.

Mais comme souvent, tu gagneras probablement plus à revoir ton algorithme de traitement sur tes entiers !

Tout dépend de ce qu'il a faire. C'est sur qu'il faut d'abord penser a un bon algorithme.

Mais franchement je doute qu'il n'ait qu'un coeur, et qu'en parallélisant ca soit pire... (sauf si tout les thread se marchent dessus pour une ressource, etc...)

Mes souvenirs remontent à loin et je n'ai pas lu l'article.
(ça commence mal, je sais)

Mais il me semble que c'est plus une question d'ordonnancement qu'une question de nombre de coeurs :
- Si le / les coeurs sont occuppés à une tâche plus prioritaire, il n'aura de toutes façons pas l'occasion de les occupper comme il le veux
- Si le / les coeurs sont libres, alors il pourra faire tourner au moins autant de Thread en parallèle (ceci sans compter les méthodes synchronized, on est d'accord)
- Sur chacun des coeurs, l'occupation de l'activité n'est pas continue : elle est séquencée. Ainsi, plusieurs Threads peuvent être exécutés "en parallèle" mais pas "en même temps" sur le même coeur.

Donc, comme le dit wax78, tout dépend de ce qu'il a à faire. Par exemple, plus tu auras d'I/O, moins ton coeur sera sollicité. Et plus il a de temps libre, plus la parallélisation sera optimisée.
En revanche, dans le cas de calculs bruts, plus de Thread que de coeurs n'aura comme effet, au mieux, que de stacker les tâches à faire. Au pire, engendrer des déplacements peu coûteux mais trop nombreux de données en mémoire.

Je me trompe ?

Il faut également prendre en compte le problème de "volatilité" des données.