Comment tuer un fil instantanément en C#?

Question

J'utilise la méthode thread.Abort pour supprimer le thread, mais cela ne fonctionne pas. Y a-t-il un autre moyen de terminer le fil?

private void button1_Click(object sender, EventArgs e) 
{ 
    if (Receiver.IsAlive == true) 
    { 
     MessageBox.Show("Alive"); 
     Receiver.Abort(); 
    } 
    else 
    { 
     MessageBox.Show("Dead"); 
     Receiver.Start(); 
    } 
} 

J'utilise cela, mais chaque fois que je reçois le statut Alive, Receiver est mon fil global.

Answer 1

La raison pour laquelle il est difficile de tuer un thread est que les concepteurs de langage veulent éviter le problème suivant: votre thread prend un verrou, puis vous le tuez avant de pouvoir le libérer. Maintenant, toute personne qui a besoin de ce verrou sera coincé.

Ce que vous avez à faire est d'utiliser une variable globale pour dire au thread de s'arrêter. Vous devez manuellement, dans votre code de thread, vérifier cette variable globale et retourner si vous le voyez indique que vous devriez arrêter.

Answer 2

thread sera détruit quand il finira son travail, donc si vous utilisez des boucles ou autre chose, vous devez passer variable au thread pour arrêter la boucle après que le thread sera terminé.

Answer 3

C# Thread.Abort n'est pas garanti pour annuler le thread instantanément. Cela fonctionnera probablement quand un thread appelle Abort sur lui-même mais pas quand un thread appelle un autre.

S'il vous plaît se référer à la documentation: http://msdn.microsoft.com/en-us/library/ty8d3wta.aspx

J'ai fait face à ce problème d'écriture des outils qui interagissent avec le matériel - vous voulez arrêt immédiat mais il est pas garanti. J'utilise généralement des drapeaux ou d'autres logiques pour empêcher l'exécution de parties de code s'exécutant sur un thread (et que je ne veux pas exécuter sur avortement).

Answer 4

Vous devez d'abord avoir une méthode convenue pour terminer le thread. Par exemple run_ valiable que le thread peut vérifier et respecter.

Votre code thread principal doit être enveloppé dans un bloc d'exception qui attrape à la fois ThreadInterruptException et ThreadAbortException qui nettoiera proprement le thread à la sortie.

Dans le cas de ThreadInterruptException, vous pouvez vérifier la variable running_ pour voir si vous devez continuer. Dans le cas de ThreadAbortException, vous devez ranger immédiatement et quitter la procédure de thread.

Le code qui tente d'arrêter le fil doit faire ce qui suit:

running_ = false; 
threadInstance_.Interrupt(); 
if(!threadInstance_.Join(2000)) { // or an agreed resonable time 
    threadInstance_.Abort(); 
} 

Answer 5

Vous pouvez le tuer faire instantanément de cette façon:

private Thread _myThread = new Thread(SomeThreadMethod); 

private void SomeThreadMethod() 
{ 
    // do whatever you want 
} 

[SecurityPermissionAttribute(SecurityAction.Demand, ControlThread = true)] 
private void KillTheThread() 
{ 
    _myThread.Abort(); 
} 

Je l'utilise toujours et fonctionne pour moi:

Answer 6

private void ResumeButton_Click(object sender, RoutedEventArgs e) 
    { 
     Task.Factory.StartNew(() => 
     { 
      Application.Current.Resources["AutoPilotThreadStatus"] = true; 
      Thread.CurrentThread.Name = "ResumeAutoPilot"; 
      Thread.CurrentThread.IsBackground = true; 
      AutoPilotHandler.ResumeAutoPilot(); 
     }); 
    } 

    public static void ResumeAutoPilot() 
    { 
     while ((bool)Application.Current.Resources["AutoPilotThreadStatus"]) 
     { 
      CheckAutoPilotThreadStatus(); 
      var searchYoutube = YoutubeHandler.Search("small truck"); 
      CheckAutoPilotThreadStatus(); 
      SaveVideosToDatabase(searchYoutube); 
      CheckAutoPilotThreadStatus(); 
     } 
    } 

    public static void CheckAutoPilotThreadStatus() 
    { 
     if (!(bool)Application.Current.Resources["AutoPilotThreadStatus"]) 
     { 
      KillCurrentThread(); 
     } 
    } 

    public static void KillCurrentThread() 
    { 
     Thread.CurrentThread.Abort(); 
    }