Multithread dans VBnet

Bonjour,
je veux lancer plusieurs instance d'une Sub avec passage de paramètre.
Le passage de paramètre j'ai pu le résoudre avec ParameterizedThreadStart.
Mais mon problème c'est que je ne sais pas combien d'instance je vais lancer
Donc quelle modification à apporter sur :

Code:

---

Dim t As New System.Threading.Thread(New Threading.ParameterizedThreadStart(AddressOf Vente))

---

pour avoir la variable t sous forme d'un tableau et pour ensuite executer :

Code:

---

1 2 3

For i = 0 To n t(i).Start(p(i)) Next

---

merci

Bonjour,

Je me permet de relever ce sujet, je me pose la même question

Comment faire un tableau de thread ?

Plus généralement comment faire une application utilisant autant de thread que de processeurs sans connaitre auparavant la machine d'exécution.
Je sais comment accéder au nombre de processeur d'une machine, mais pas comment lancer un nombre de thread en conséquence.


Merci pour votre aide :)

threadpool
System.Environment.ProcessorCount ca compte les processeurs logiques du pc, je ne pense pas que ca vaut le nombre de processeurs logiques que le processus a le droit d'utilier, bienque personne ne s'amuse à décocher des cores en général ^^

et on fait un tableau de thread comme on fait un tableau de string ...

concernant les paramètres on peut les placer quelque part et que le thread viennent les chercher ...

Citation:

---

Plus généralement comment faire une application utilisant autant de thread que de processeurs sans connaitre auparavant la machine d'exécution.
Je sais comment accéder au nombre de processeur d'une machine, mais pas comment lancer un nombre de thread en conséquence.

---

Je suis pas un spécialise du multithread, ni du calcul parallèle, mais ce passage m'interpelle!

Il n'y a pas de rapport, à ma connaissance, entre le nombre de processeur et le nombre de thread qu'on peux lancer (un processeur peut très bien heberger plusieurs thread et ceci depuis longtemps).

Je ne doute pas de l'interêt de limiter le nombre de thread lancé lors d'un calcul parallèle sur 10'000 élément. Mais je pense pas que de faire un tableau de thread de la taille du nombre de processeur soit la meilleur solution pour traiter cette problématique.

Mais je vais suivre la suite de la discussion avec interet!

certaines applications ont plusieurs centaines de threads (sql server par exemple) qui sont gérés par l'os car le processeur lui ne peut réellement gérer que 1 thread par core logique (l'hyperthreading d'intel créé 2 cores logiques pour 1 core physique)
avoir autant de thread n'est utile que dans le cas où certains threads restent inactifs et bouclent à l'infini (comme par exemple un thread qui écoute sur le réseau, quand il n'y a rien qui arrive il ne fait rien etc...)

pour des threads de traitement avec une fin avoir plus de threads que de core peut ralentir l'exécution, typiquement avoir une collection de 1000 éléments, avoir 100 threads de 10 éléments va ralentir car l'os doit décharger et recharger les données des threads dans les cores
avec 4 cores et donc 4 threads qui vont traiter 250 éléments ca pourrait être le plus optimal, si toutefois on ne tiens pas compte que d'autres processus ont besoin des threads, mais on peut en faire abstraction ^^

on peut donc lancer x threads selon le nombres de cores (propriété cité dans mon précédent message)

quand on a besoin d'un thread par objet, la classe threadpool peut être utile, c'est elle qui s'occupe de "démarrer" un thread quand un se finit, maintenant le nombre de thread actif à la limite qu'on lui fixe
j'ai mis "démarer" car les threads ne sont pas instanciés réellement je pense, mais plutot repris du pool gagnant ainsi un peu de temps

le composant backgroundworker est aussi une classe pratique pour du multithreading, elle possède des évènements qui reviennent sur le thread principal, permettant de modifier l'interface graphique


un exemple pour des threads qui doivent chacun gérer 100 éléments d'une collection de 400 éléments (il convient de rendre ca dynamique)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

private _DicoIndexCollectionParThread as dictionary(of thread, integer)   private sub StartThreads for i as integer = 0 tp 3 dim th as new thread(addressof traitement) DicoIndexCollectionParThread.add(th, i*100) th.Start next end sub   private sub traitement dim depart as integer = DicoIndexCollectionParThread (System.Threading.Thread.CurrentThread) for i as integer = depart to depart + 99 traitement sur collection(i) next end sub

---

à noter aussi que le framework 4 dispose des boucles paralleles que je ne connais pas mais qui si j'ai bien compris s'écrit à peu près comme ca

Code:

---

parallel.foreach(collection)

---

qui il me semble créé un nombre de thread équivalent au nombres de cores dispos et chaque thread traite un élément de la collection, puis en prend un autre quand il a fini

Citation:

---

Envoyé par sinople

Je suis pas un spécialise du multithread, ni du calcul parallèle, mais ce passage m'interpelle!

Il n'y a pas de rapport, à ma connaissance, entre le nombre de processeur et le nombre de thread qu'on peux lancer (un processeur peut très bien heberger plusieurs thread et ceci depuis longtemps).

Je ne doute pas de l'interêt de limiter le nombre de thread lancé lors d'un calcul parallèle sur 10'000 élément. Mais je pense pas que de faire un tableau de thread de la taille du nombre de processeur soit la meilleur solution pour traiter cette problématique.

Mais je vais suivre la suite de la discussion avec interet!

---

Je ne pense pas pouvoir expliquer mieux que Pol. Dans mon cas j'effectue un calcul assez bête qui va tester de multiples instances de 3 variables indépendantes afin d'optimiser un R2... Je rentre pas dans les détails.
Grosso modo je parallélise 3 boucles d'un même calcul mais sur des bornes différentes. D'où l'intérêt de découper le calcul en fonction du nombre de processeurs. Car comme l'explique Pol, un multithread sur un seul processeur ne permet pas de paralléliser un calcul tel que le mien, je ne gagnerais pas en temps :)

Je n'ai pas encore creusé les solutions présentés mais merci d'avance pour votre aide.
Bonne journée :)

Citation:

---

Envoyé par ArnSpin

Car comme l'explique Pol, un multithread sur un seul processeur ne permet pas de paralléliser un calcul tel que le mien, je ne gagnerais pas en temps :)

---

ah ?

ce qui est impossible à multithreader ou du moins compliqué c'est quand le traitement d'un élément dépend du résultat de l'élément précédent ...

Bien dans le cas où je n'aurais qu'un seul processeur mais 2 thread, j'aurais une exécution de ma première boucle, puis de la seconde, bien qu'indépendantes elles s'exécutent seulement l'une après l'autre ? Un processeur fait un calcul à la fois.

Si je comprends bien tout ça hein, je suis novice.

Pour grossir le trait dans mon cas
Sans multithread j'ai

boucle 1 à 1e9
calcul...

Avec multithread - multiprocesseur j'ai

thread 1 - processeur 1
boucle 1 à 0.3e9
calcul...

thread 2 - processeur 2
boucle 0.31e9 à 0.6e9
calcul...

thread 3 - processeur 3
boucle 0.61e9 à 1e9
calcul...

L'intérêt et de voir s'exécuter ces boucles toutes en même temps, donc de leurs associer un processeur à chacune. Après je fais ma tambouille avec les résultats obtenus...

J'ai bon là ?

les threads s'exécutent tous en même temps mais aussi chacun leur tour :D

pour schématiser sur windows il y a plusieurs processus (exe) qui s'exécutent en même temps avec chacun entre 1 et x threads
dans le cas d'un seul processeur avec un seul core, windows laisse un laps de temps à chaque processus (en nanosecondes peut etre), et dans ce laps de temps, un laps de temps à chaque thread du processus
une fois le temps écoulé, l'exécution se met en pause et un autre est envoyé au core

donc les threads progressent tous en même temps
quand il y a plusieurs cores et/ou plusieurs processeurs, windows en fait tourner plusieurs processus ou plusieurs threads en même temps

dans le cas du threadpool, celui ci attend qu'un thread soit terminé pour en relancer un, et donc c'est bien consécutif comme tu le décris, enfin seulement si tu dis que le threadpool ne doit pas dépasser un thread en exécution à la fois

si tu n'as qu'un processeur, tu peux quand même avoir plusieurs core, ca fait maintenant plusieurs année qu'on trouve des dual core et des quad core, et sur les serveurs on peut en trouver parfois 32

si tu utilises le threadpool en définissant le maxthread au nombre de core de la machine tu auras toujours le plus performant

Pardon, j'ai usé d'un vilain abus de langage en mélangeant core et processeur.
Dans mon exemple plus je voulais dire Core 1, core 2 etc...
Ma machine de travail est en effet un quad core.