Tuer un thread en cours d'exécution

Ce qui se passe si nous force à tuer un thread en cours d'exécution

J'ai un fil à savoir RecordThread() qui appelle certaines complexe et fastidieuse fonctions. Dans ces fonctions, je suis en utilisant try-catch blocs, l'allocation et la désallocation de la mémoire et à l'aide de la section critique variables etc.

comme

  void RecordThread()
  {
    AddRecord();
    FindRecord();
    DeleteRecord();
    //...
    ExitThread(0);
   }

Après la création de ce thread, je suis immédiatement de le tuer avant de le thread termine son exécution. Dans ce cas, qu'advient-il si le thread est avec force tué? Faire les fonctions internes (AddRecord, DeleteRecord) à terminer leur exécution après nous avons tué le fil?

OriginalL'auteur Aneesh Narayanan | 2012-05-24

c++multithreading windows

13

Après la création de ce thread, je suis immédiatement de le tuer avant de le thread termine son exécution.

Je suppose que vous dire que vous êtes en utilisant TerminateThread() de la manière suivante:
```
HANDLE thread = CreateThread(...);

//...
//short pause or other action?
//...

TerminateThread(thread, 0); //Dangerous source of errors!
CloseHandle(thread);
```
Si c'est le cas, alors non, le thread exécutant RecordThread() sera arrêté exactement où il est pour le moment que l'autre thread appelle TerminateThread(). Selon les notes dans le TerminateThread() de la documentation, de ce point est quelque peu aléatoire et dépend de complexes problèmes de synchronisation qui sont hors de votre contrôle. Cela implique que vous ne pouvez pas gérer correctement le nettoyage à l'intérieur d'un thread et donc, vous devez rarement, si jamais, tuer un thread.

La bonne façon de demander le fil à la fin, est en utilisant WaitForSingleObject() comme suit:
```
HANDLE thread = CreateThread(...);

//...
//some other action?
//...

//you can pass a short timeout instead and kill the thread if it hasn't
//completed when the timeout expires.
WaitForSingleObject(thread, INFINITE);
CloseHandle(thread);
```
Pour le rendre plus explicite: TerminateThread peut tuer votre fil dans le milieu de la i++ déclaration. Il n'essayez pas de rechercher le "gentil" points tels que les appels de fonction.
Notez que POSIX est très différente de l'API Win32 en ce sens (par défaut, sauf si le thread a modifié son annulation paramètres), il sera en effet seulement de tuer votre fil à une annulation point. Donc en plus d'être dangereux, il n'est même pas aussi dangereux partout, et ne sont donc pas "portable" 🙂
Si ce n'est pas évident de les autres commentaires, quelques raisons de plus pourquoi vous devriez ne jamais les utiliser TerminateThread: Windows a commencé à ramasser les morceaux vraiment gros de TerminateThread des ordures sur le trottoir, mais c'est toujours les ordures sur le trottoir

OriginalL'auteur André Caron
3

tuer le thread est le dernier recours - André a indiqué qu'il laisse de données en état inconnu, vous ne devriez jamais faire que si la thread travaille sur des objets partagés. Les meilleurs choix de notifier fil pour terminer le travail par:

-utilisation de global volatils (important) de la variable qui n'est modifiée que par le thread principal et testé par les travailleurs

-à l'aide de signal type de synchronisation des objets (principalement des Événements), également définies par thread principal et testé par les travailleurs

OriginalL'auteur Piotr Tkaczyk
2

http://msdn.microsoft.com/en-us/library/windows/desktop/ms682659%28v=vs.85%29.aspx

ExitThread est la méthode préférée de la sortie d'un fil dans le code C. Cependant, dans le code C++, le fil est sorti avant tout destructeurs peuvent être appelés ou de tout autre nettoyage automatique peut être effectuée. Par conséquent, dans le code C++, vous devez retourner à partir de votre fonction de thread.

Cependant les appels de fonction sera évidemment terminé parce qu'ils sont appelés à témoigner devant le ExitThread().

Que faire si ils n'ont pas assez de temps pour terminer?
comme en single-threaded code séquentiel cohérence garantit que toutes les lignes avant ExitThread() se termine.

OriginalL'auteur Vladimir Sinenko

exemple de Fil qui fonctionne bien:

definition in *.h ------------------------------------

DWORD WINAPI Th_EspectroIF(LPVOID lpData);

CThread th_espectro(Th_EspectroIF);

use in *.cc -----------------------------------

DWORD WINAPI Th_EspectroIF(LPVOID lpData)
{

//Your code...

th_espectro.Stop(true);//stop this Thread 

}

appeler le Thread avec: th_espectro.Start();

Bienvenue à Débordement de Pile. Code-seules réponses sont découragés. Comment est-ce la réponse, différentes ou mieux que les précédentes réponses?

OriginalL'auteur octavio oli

Vous devez vous connecter pour publier un commentaire.