Discussion :

[topolino]

Bonjour,

J'ai un thread qui execute une tache plus ou moins longue. Une fois cette tache fini je veux appeler d'autre methodes de traitements.

J'ai essayé thread.join() mais cela bloque mon UI idem en faisant while(thread.isAlive).

Avez vous une solution ?

Merci

[Bluedeep]

- tu crées un objet de synchro (style ManualResetEvent)
- dans le thread qui attend tu fais un WaitOne dessus
- ton thread qui fait le traitement le met à l'état signalé quand il a finit

[topolino]

Oui mais mon UI se fige du coup.
Comme le traitement peut etre long alors tout plante

[Bluedeep]

Oui mais mon UI se fige du coup.
Comme le traitement peut etre long alors tout plante

Il y a quelque chose que je ne comprends pas :

- ou tu as besoin d'attendre la fin de ton traitement, et dans ce cas je ne vois pas de soucis à figer l'UI puisque tu ne peux rien faire d'autre.

- ou tu ne veux pas figer ton UI car l'utilisateur peut faire d'autres actions, et dans ce cas tu n'as pas besoin d'attendre la fin de ton traitement.

Peux tu préciser un peu plus ton besoin ?

Sinon, si tu veux par exemple ne pas figer l'UI et mettre un indicateur quand le traitement est fini, fais le faire éventuellement par le thread qui fait le traitement.

[topolino]

Peut etre que je m'y prends mal.

En faite j'ai developpé un parser pour un intranet qui va scruter toutes les pages web pour y recueillir certaines informations. J'aimerais lancer plusieurs parsers en meme tps qui doivent appeler les memes methodes mais avec des parametres differents.

[DonQuiche]

Si tu demandes à ton thread UI d'attendre la fin du traitement, il est normal que l'UI se fige. Ce que tu veux, ce n'est pas mettre le thread UI en attente mais déclencher une action pour mettre à jour l'UI une fois les threads esclaves terminés, le thread UI continuant à courir et pomper les messags en attendant que les esclaves aient achevés leurs tâches.

Pour ça, il te suffit d'insérer à la fin des traitements effectués par les threads un appel de mise à jour de l'UI (préférablement un délégué de rappel - callback - qui aura été passé par l'UI au thread esclave lors de la création de celui-ci).

Code :

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
 
void StartThread()
{
   ...
   myThread.Start(() => Run(uiCallback));
}
 
void Run(Action uiCallback)
{
   try
   {
      // Exécute les traitements
      ...
   }
   finally
   {
      // Notifie l'UI que nous avons terminé
      uiCallback();
   }
}

Idéalement, uiCallback devrait être rapide à exécuter: il devrait rapidement aboutir à un simple appel de Control.BeginInvoke(OnThreadOver), l'essentiel des traitements se déroulant alors dans OnThreadOver et sur le thread UI, laissant le thread esclave libre de se terminer.

Note que dans ce code, uiCallback sera appelé même en cas de OutOfMemoryException ou ThreadAbortException (notamment à la fermeture de l'appli). A toi de gérer ces cas ou de revoir le code proposé.

[sinople]

Je crois que ce qu'il nous manque c'est surtout le traitement que tu veux faire une fois que tes parsers ont fini leur boulot.

Mais d'après ce que j'ai compris tu dois pouvoir t'en tirer avec l'idée suivante:

Tu crées un tableau, Liste de Boolean pour chaque tâches pour laquelle tu va lancer un thread.

Lorsqu'un thread à terminé son boulot, il met à jour sa référence booleanne à vrai et lance un évenement à invoker sur le thread principal qui va vérifier l'état de la liste des boolean afin de :

Mettre à jour une barre de progression si nécessaire (Avec le rapport nombre de boolean à true sur le nombre de boolean).
Lancer une nouvelle tâche si tout les boolean sont à true. (Tous les threads ont alors fini leur boulot)

Il faut bien sur adapter le concept pour gérer les erreurs des threads qui plantent.

Autrement tu peux faire un thread qui va séquentiellement faire le boulot de tes parsers et ensuite faire le traitement final. En effet il faut savoir que de multiplier les thread à l'infini ne va pas multiplier les performances pour autant (Idéalement il faut pas dépasser le nombre de coeur des processeurs de la machine).

Donc si l'objectif principal est de ne pas bloquer l'interface utilisateur, un thread secondaire est suffisant.

[swif79]

Bonjour,
Tu peux peut être faire plus simple avec la TPL, dans formLoad tu récupère le
SynchronizationContext de ton thread UI.

Code :

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

1
2
3
4
5
6
 
private static SynchronizationContext _Context;
private void Form1_Load(object sender, EventArgs e)
{
       _Context = SynchronizationContext.Current;          
}

Ensuite quand tu dois lancer tes tâches

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
Task.Factory.StartNew(() =>
{
      //Traitement long
     Parallel.ForEach(this._UrlList, url =>
           {
                  this.ParsePages(url);
                  _Context.Post(state =>
                 {
                        //Mise à jour de l'UI
                 }, null);
           });
});

En effet il faut savoir que de multiplier les thread à l'infini ne va pas multiplier les performances pour autant (Idéalement il faut pas dépasser le nombre de coeur des processeurs de la machine).

Sauf erreur de ma part la TPL ne dépassera pas ce nombre.