Comment mettre fin à un correctement thread de travail en C#

Question

déclaration Problème

J'ai un thread de travail qui scanne essentiellement un dossier, d'entrer dans les fichiers qu'il contient, et dort ensuite pendant un certain temps. L'opération de numérisation peut prendre 2-3 secondes mais pas beaucoup plus. Je cherche un moyen d'arrêter ce fil avec élégance.

Précision: Je veux arrêter le fil alors qu'il est dormir, et non pendant qu'il est balayage. Cependant, le problème est que je ne sais pas quel est l'état actuel du thread. S'il dort, je veux qu'il sorte immédiatement. Si c'est la numérisation, je veux qu'il sorte du moment où il essaie de bloquer.

Les tentatives d'une solution

Au début, je mise en veille et d'interruption. Ensuite, j'ai découvert que l'interruption n'interrompt pas vraiment le sommeil - cela ne fonctionne que lorsque les threads essaye de dormir.

Donc, je suis passé à Monitor Wait & Pulse. Puis j'ai découvert que le Pulse ne fonctionne que lorsque je suis en attente. Alors maintenant j'ai un fil qui ressemble à ça:

while (m_shouldRun) 
{ 
    try 
    { 
     DoSomethingThatTakesSeveralSeconds(); 
     lock (this) 
     { 
      Monitor.Wait(this, 5000); 
     } 
    } 
    catch (ThreadInterruptedException) 
    { 
     m_shouldRun = false; 
    } 
} 

Et maintenant j'ai besoin de créer ma fonction Stop. Alors j'ai commencé avec:

public void Stop() 
{ 
    m_shouldRun = false; 
    lock (this) 
    { 
     Monitor.Pulse(this); 
    } 
    thread.Join(); 
} 

Mais cela ne fonctionne pas parce que je peux être pulsant pendant que les travaux de fil (alors qu'il est pas en attente). J'ai donc ajouté Interrompre:

public void Stop() 
{ 
    m_shouldRun = false; 
    thread.Interrupt(); 
    lock (this) 
    { 
     Monitor.Pulse(this); 
    } 
    thread.Join(); 
} 

Une autre option consiste à utiliser:

public void Stop() 
{ 
    m_shouldRun = false; 
    while (!thread.Join(1000)) 
    { 
     lock (this) 
     { 
      Monitor.Pulse(this); 
     } 
    } 
} 

La question

Quelle est la méthode préférée? Y a-t-il une troisième méthode préférable?

Answer 1

Une autre alternative consiste à utiliser des événements:

private ManualResetEvent _event = new ManualResetEvent(false); 


public void Run() 
{ 
while (true) 
{ 
    DoSomethingThatTakesSeveralSeconds(); 
    if (_event.WaitOne(timeout)) 
     break; 
} 
} 

public void Stop() 
{ 
    _event.Set(); 
    thread.Join(); 
} 

Answer 2

La façon d'arrêter un fil avec élégance est de le laisser finir par lui-même. Donc, à l'intérieur de la méthode worker, vous pouvez avoir une variable booléenne qui va vérifier si nous voulons interrompre. Par défaut, il sera défini sur false et lorsque vous le définissez sur true à partir du thread principal, il arrêtera simplement l'opération d'analyse en rompant avec la boucle de traitement.

Answer 3

je vous recommande de le garder simple:

while (m_shouldRun) 
{ 
    DoSomethingThatTakesSeveralSeconds(); 
    for (int i = 0; i < 5; i++) // example: 5 seconds sleep 
    { 
     if (!m_shouldRun) 
      break; 
     Thread.Sleep(1000); 
    } 
} 

public void Stop() 
{ 
    m_shouldRun = false; 
    // maybe thread.Join(); 
} 

Cela présente les avantages suivants:

• Il sent comme attente occupé, mais ce n'est pas. $ NUMBER_OF_SECONDS vérifications sont effectuées au cours de la phase d'attente, ce qui n'est pas comparable aux milliers de contrôles effectués dans l'attente réelle occupé.
• C'est simple, ce qui réduit considérablement le risque d'erreur dans le code multithread. Tout ce que votre méthode Stop doit faire est de mettre m_shouldRun à false et (peut-être) d'appeler Thread.Join (s'il est nécessaire que le thread se termine avant que Stop ne reste).Aucune primitive de synchronisation n'est nécessaire (sauf pour marquer m_shouldRun comme volatil).

Answer 4

je suis venu avec la programmation séparément la tâche.

using System; 
using System.Threading; 

namespace ProjectEuler 
{ 
    class Program 
    { 
     //const double cycleIntervalMilliseconds = 10 * 60 * 1000; 
     const double cycleIntervalMilliseconds = 5 * 1000; 
     static readonly System.Timers.Timer scanTimer = 
      new System.Timers.Timer(cycleIntervalMilliseconds); 
     static bool scanningEnabled = true; 
     static readonly ManualResetEvent scanFinished = 
      new ManualResetEvent(true); 

     static void Main(string[] args) 
     { 
      scanTimer.Elapsed += 
       new System.Timers.ElapsedEventHandler(scanTimer_Elapsed); 
      scanTimer.Enabled = true; 

      Console.ReadLine(); 
      scanningEnabled = false; 
      scanFinished.WaitOne(); 
     } 

     static void scanTimer_Elapsed(object sender, 
      System.Timers.ElapsedEventArgs e) 
     { 
      scanFinished.Reset(); 
      scanTimer.Enabled = false; 

      if (scanningEnabled) 
      { 
       try 
       { 
        Console.WriteLine("Processing"); 
        Thread.Sleep(5000); 
        Console.WriteLine("Finished"); 
       } 
       finally 
       { 
        scanTimer.Enabled = scanningEnabled; 
        scanFinished.Set(); 
       } 
      } 
     } 
    } 
}