Discussion :

[azerty25]

Bonjour

Je me lance dans le threading et j'ai pas trouvé comment faire pour mettre une fonction dans un thread, ou comment récupèrer un résultat de fonction d'un autre thread.

Par exemple, si je fais

Code :

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

1
2
        Dim t As New Thread(AddressOf MaFunction)
        t.Start()

Il me dit :

Code :

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

1
2
3
4
5
 
Erreur	6	
La résolution de surcharge a échoué, car aucun 'New' accessible ne peut être appelé avec ces arguments*:
    'Public Sub New(start As System.Threading.ParameterizedThreadStart)': La méthode 'Public Function MaFunction() As Object' n'a pas la même signature que le délégué 'Delegate Sub ParameterizedThreadStart(obj As Object)'.
    'Public Sub New(start As System.Threading.ThreadStart)': La méthode 'Public Function MaFunction() As Object' n'a pas la même signature que le délégué 'Delegate Sub ThreadStart()'.

Non seulement la signature ne va pas, mais ne permet pas non plus de récupèrer le résultat... J'ai cherché sur Google, j'ai vu une page traitant, il me semble, du sujet. Ils parlaient de mettre une classe avec des propriétés en thread et les propriétés seraient les résultats des fonctions de la classe ?! Enfin bon, j'ai pas tout saisis, car c'était de l'ASP.
Auriez vous une piste ?

[cinemania]

Salut,

Le threading fonctionne de la même façon quelque soit le langage... la seule question reste de savoir comment on l'utilise...

Sous le framework .NET, c'est le même principe que si tu programmais l'API Windows ou si tu utilise la lib pthreads.h sous linux.
Tu dispose seulement d'une classe en plus qui s'appel Thread qui permet d'encapsuler les appels au système pour la gestion des threads.

Il existe DEUX delegués pour les threads en .NET2.0.

delegate void ThreadMethod();
delegate void ThreadMethod(object Parameter);

Le premier est le délégué standard, le second un délégué paramètré pour fournir un paramètre au thread au moment où il est lancé.
Comme tu pourras le constater... pas de résultat... l'explication est simple.

Quand on lance un traitement dans un thread, c'est pour que ce traitement se fasse en arrière plan... sans bloquer et encombrer le thread principal occupé à gérer autre chose. Qui dit ARRIERE PLAN dit aussi Asynchrone. La nature asynchrone fait qu'il n'est pas possible de récupérer un résultat car un thread n'est qu'une méthode, car de toute facon à moins de faire un Join sur le thread en question (et ça n'est utile que dans des cas précis) tu ne peux pas savoir exactement, depuis ton thread principal, quand le thread secondaire va cessé d'être exécuter et s'arrêter.

Si tu as besoin d'un traitement simple en arrière plan, je te suggère vivement l'emploi de classes telles BackgroundWorker, certainement plus adaptées à ton besoin.
Si tu as vraiment besoin de traitement paralleles.;. le threading est ton amis, mais dans ce cas je te suggère de lire des articles sur le threading... pas que sur la façon d'instancier un thread, mais surtout sur les principes sous jacents comme la synchronisation...

Si tu veux fournir plus d'un paramètre et obtenir un résultat d'exécution d'un thread, tu peux très bien te créer une classe spécifique comme base qui s'en chargera...

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
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public abstract class MyThreads<S,T> {
  private Thread m_Thread;
  private T m_Result;
  private S m_Parameter;
  private object m_Lock = new object ();

  protected MyThreads(S param) 
  {
    m_Parameter = param;
    m_Thread = new Thread(Runner);
    m_Result = default(T);
  }

  /// <summary>
  /// Méthode à surcharger dans laquelle tu met tranquillement le code de ton
  /// thread.
  /// </summary>
  protected abstract void Run();
  private void Runner() {
    try {
      Run();
    }
    catch (Exception ex) {
      throw ex; 
    }
    finally {
      OnEnd(new EventArgs());
    }
  }
  private void OnEnd(EventArgs e) {
    if (Ended != null) Ended(this, e);
  }

  public void Start() { m_Thread.Start(); }
  public void Stop() { m_Thread.Stop(); }
  public void Abort() { m_Thread.Abort(); }

  public T Result { get { lock (m_Lock) return m_Result; } }
  public bool Running { get { return m_Thread.IsAlive; } }
  public event EventHandler Ended;
}

Bon j'lai écrite en C# parce que je préfère C#, mais le principe RESTE EXACTEMENT le même.
Maintenant tu peux enrichir ta classe pour qu'elle contienne d'autres axiomes tels des mécanisme de synchronisation ... peut importe, c'est un exemple.

Ensuite pour chaque type de thread que tu veux faire tu fait un thread genre

Code :

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

1
2
3
4
5
6
7
8
9
public class MyThread1 : MyThreads<string, string>
public MyThread1(string param) : base(param) {};
protected override void Run() {
  ...
  lock(m_Lock) m_Result = ...;
  ...
}
}

Dans tous les cas il ne faut pas oublier de synchroniser l'appel à m_Result, pour éviter que deux threads concurrents n'y accède en même temps.
En prime ta classe abstraite est Thread-Safe que demander de mieux ?

[azerty25]

Bonjour

Je te remercie beaucoup d'avoir pris du temps pour écrire une réponse si détaillée qui m'aide bien ! Je vais me pencher sur ton code pour l'adapter.
J'ai en effet besoin de lancer plusieurs opérations en parallèle et de ne pas geler l'interface, et les thread travaillent à extraire des données, donc il faut que je les récupère ...
Encore merci !