Arrêt d'une application multithread

Question

J'essaye d'écrire un ThreadManager pour mon application C#. Je crée plusieurs threads:
Un fil pour mon écrivain de texte.
Un thread qui surveille certaines statistiques.
Plusieurs threads pour effectuer une grande séquence de calculs (jusqu'à 4 threads par core et je lance mon application sur un serveur quad core 2x).

Mon application s'exécute normalement jusqu'à 24 heures à la fois, de sorte que tous les threads sont créés au début et qu'ils persistent tout le temps que l'application s'exécute.

Je veux avoir un seul endroit où je "enregistre" toutes mes bandes de roulement et quand l'application s'arrête, j'appelle simplement une méthode et elle passe par tous les threads enregistrés et les ferme.

A cette fin, je l'ai mis au point la classe suivante:

public class ThreadManager 
{ 
    private static Object _sync = new Object(); 
    private static ThreadManager _instance = null; 
    private static List<Thread> _threads; 
    private ThreadManager() 
    { 
     _threads = new List<Thread>(); 
    } 

    public static ThreadManager Instance 
    { 
     get 
     { 
      lock (_sync) 
      { 
       if (_instance == null) 
       { 
        _instance = new ThreadManager(); 
       } 
      } 
      return _instance; 
     } 
    } 

    public void AddThread(Thread t) 
    { 
     lock (_sync) 
     { 
      _threads.Add(t); 
     } 
    } 

    public void Shutdown() 
    { 
     lock (_sync) 
     { 
      foreach (Thread t in _threads) 
      { 
       t.Abort(); // does this also abort threads that are currently blocking? 
      } 
     } 
    } 
} 

Je veux faire en sorte que tous mes fils sont tués pour que l'application peut se fermer correctement et arrêter au milieu d'un calcul est très bien aussi. Devrais-je être au courant de quelque chose ici? Cette approche est-elle bonne compte tenu de ma situation?

Answer 1

Si vous définissez les threads sur les threads d'arrière-plan, ils seront supprimés lorsque l'application sera arrêtée. De toute évidence, si vous avez besoin des threads pour terminer avant l'arrêt, ce n'est pas la solution que vous voulez.

Answer 2

La seule question spécifique que je sais est celui-ci: http://www.bluebytesoftware.com/blog/2007/01/30/MonitorEnterThreadAbortsAndOrphanedLocks.aspx

Mais il faut éviter d'avoir à recourir à une conception comme celui-ci. Vous pouvez forcer chacun de vos threads à vérifier régulièrement un drapeau qu'il est temps de s'arrêter, et lors de la fermeture, placez ce drapeau et attendez que tous les threads se terminent (avec Join()). Cela ressemble un peu plus à un arrêt contrôlé de cette façon.

Answer 3

L'annulation de threads est ce que vous faites lorsque tout le reste échoue. C'est une chose dangereuse à faire que vous ne devriez faire qu'en dernier recours. La façon correcte de faire cela est de rendre votre logique de threading afin que chaque thread de travail réponde rapidement et correctement quand le thread principal lui donne la commande de se fermer.

Par coïncidence, c'est le sujet de mon blog cette semaine.

http://blogs.msdn.com/ericlippert/archive/2010/02/22/should-i-specify-a-timeout.aspx

Answer 4

si AddThread est appelé pendant que votre arrêt est en marche?

Lorsque l'arrêt est terminé, le thread en attente dans AddThread ajoute un nouveau thread à la collection. Cela pourrait entraîner des blocages dans votre application.

Ajoutez un indicateur bool que vous définissez uniquement dans Shutdown pour vous protéger contre cela.

bool shouldGoAway = false; 
public void AddThread(Thread t) 
{ 
    lock (_sync) 
    { 
     if(! shouldGoAway) 
      _threads.Add(t); 
    } 
} 

public void Shutdown() 
{ 
    lock (_sync) 
    { 
     shouldGoAway = true; 
     foreach (Thread t in _threads) 
     { 
      t.Abort(); // does this also abort threads that are currently blocking? 
     } 
    } 

De même, vous ne devriez pas utiliser de membres statiques - il n'y a aucune raison pour cela puisque vous avez votre instance de Singleton.

.Abort() n'annule pas les threads qui bloquent dans l'espace non géré.Donc, si vous faites cela, vous devez utiliser un autre mécanisme.

Answer 5

Si vous ne se soucient pas de la boucle état de thread de travail, vous pouvez par _thread et interrompra:

void DieDieDie() 
{ 
    foreach (Thread thread in _thread) 
    { 
     thread.Abort(); 
     thread.Join(); // if you need to wait for the thread to die 
    } 
} 

Dans votre cas, vous pouvez probablement les abandonner tout et l'arrêt comme ils le font tout simplement des calculs . Mais si vous devez attendre une opération d'écriture de base de données ou devez fermer une ressource non gérée, vous devez soit capturer l'exception ThreadAbortException, soit signaler aux threads de se tuer correctement.

Answer 6

Vous voulez différée annulation de fil, ce qui signifie essentiellement que les fils se terminent par opposition à un gestionnaire de threads annulation threads de manière asynchrone, ce qui est beaucoup plus mal défini et dangereux.

Je vous voulais gérer l'annulation de fil plus élégante que la résiliation immédiate, vous pouvez utiliser les gestionnaires de signaux qui sont déclenchés par des événements hors du fil - par votre gestionnaire de fil peut-être.