Bonjour,

Je créer actuellement un programme, je voudrais amélioré sa vitesse en utilisant le MultiThreading.

Ce que j'ai fais :

'10 BackgroundThreadWorker créer précédemment
Public Class Form1
    Public datathread1 As String
    Public datathread2 As String
    Public datathread3 As String
    Public datathread4 As String
    Public datathread5 As String
    Public datathread6 As String
    Public datathread7 As String
    Public datathread8 As String
    Public datathread9 As String
    Public datathread10 As String
    Public finish As Boolean = False
    Sub init()
        finish = False
        While finish = False
            If Not thread1.IsBusy() Then
                datathread1 = "Blabla"
                thread1.RunWorkerAsync()
            End If
            If Not thread2.IsBusy() Then
                datathread2 = "Blabla"
                thread2.RunWorkerAsync()
            End If
            If Not thread3.IsBusy() Then
                datathread3 = "Blabla"
                thread3.RunWorkerAsync()
            End If
            If Not thread3.IsBusy() Then
                datathread4 = "Blabla"
                thread4.RunWorkerAsync()
            End If
            If Not thread4.IsBusy() Then
                datathread5 = "Blabla"
                thread5.RunWorkerAsync()
            End If
            '.......................................
            If Not thread10.IsBusy() Then
                datathread10 = "Blabla"
                thread10.RunWorkerAsync()
            End If
        End While
    End Sub
End Class

Bon c'est assez bourin, ce que j'aimerais savoir c'est si il est possible de faire un système plus "autonome". Un gros while qui lance des threads à chaque fois (avec une limite bien sur)(Sans avoir préalablement créer un BackgroundThreadWorker). Il fait toute les déclaration et le lance directement.

Voilà, merci

Salut,

Petite correction : utiliser des threads permet d'avoir une application plus fluide et non pas plus rapide.

Si j'ai compris, tu veux qu'à la fin d'une éxecution d'un BackgroundWorker, un autre soit lancé et ainsi de suite ?
Utilise RunWorkerCompleted pour pouvoir lancé un nouveau BackgroundWorker.

Oublies le While car ton application risque de se figer...

Citation : Yonpo

Petite correction : utiliser des threads permet d'avoir une application plus fluide et non pas plus rapide.

Faux.

Dans ton cas utilise un thread pool ca sera le mieux, le task based est bien plus performant que le lancement de threads a la volé !

Tout d'abord merci a vous deux pour vos réponse !

Citation : Yonpo

Petite correction : utiliser des threads permet d'avoir une application plus fluide et non pas plus rapide.

Je crois que je n'ai pas été tout a fait clair
Les threads servent a faire une grosse tache plus rapidement (En la décomposant en plus plusieurs petites, et dans relancer jusqu'a ce que la grosse tache soit finit (d'ou le while).).

Citation : Yonpo

Oublies le While car ton application risque de se figer...

Non car justement, le while est lui même dans un thread.

Je vais faire un schéma :

Lancement de l'application => Lancement du thread principal => While principal => Lancement de thread à la volé pour que l'application finit sa tache plus rapidement. (Imaginons que chaque thread doit charger une page web)

Citation

Citation : Yonpo

Petite correction : utiliser des threads permet d'avoir une application plus fluide et non pas plus rapide.

Faux. Je ne mis connais pas trop mais je peux t'assurer que dés que ton processeur possède au moins 2 coeurs ça sera plus rapide.

Par example si tu as 2 coeurs et 1 thread, ce thread sera limité à 50% de la puissance du processeur. Tandis que 2 thread ils seront chaqu'un limité à 50% pour un total de 100% de la puissance du processeur. (J'ai pas rpis en compte l'OS, les autres programmes ...)

Je peux enfin répondre (une mauvaise manip au post précédent m'a empêché de le faire )

Citation : AwpSoLeet

Citation : Yonpo

Petite correction : utiliser des threads permet d'avoir une application plus fluide et non pas plus rapide.

Faux.

Mon post était uniquement lié au code posté. Je suis parti du principe qu'un BackgroundWorker était executé à la fois.
Donc le thread du GUI et un autre pour le gros traitement. Dans ce cas, l'application parrait plus fluide... (une grosse tâche à la fois)
Mais avec les infos supplémentaires ajoutés par l'auteur, je suis tout à fait d'accord avec vous...

Citation : kirua29

while est lui même dans un thread.

=> OK

Comme AwpSoLeet l'a indiqué, utiliser le ThreadPool serait bien plus approprié ici.

Une autre solution plus "moderne" serait de définir une collection (liste par ex) contenant toutes les données à traiter en parallèle, et d'utiliser l'extension Linq AsParallel() pour obtenir un itérateur sur lequel il suffira de boucler pour déclencher le traitement en parallèle. Plus d'infos ici (en Anglais).

Après plusieurs essai, le Threadpool me semble être une alternative très intéressante ! J'ai fais quelque essai et c'est ce qu'il me faut ! Je vous remercie.