Comment puis-je arrêter un thread en C++11?

1. On pourrait appeler std::terminate() partir de n'importe quel fil et le fil que vous faites allusion à l'forcera la fin.

2. Vous pouvez vous arranger pour ~thread() à exécuter sur l'objet du thread cible, sans intervenir join() ni detach() sur cet objet. Cela aura le même effet que l'option 1.

3. Vous pouvez concevoir une exception qui a un destructeur qui lève une exception. Et puis prendre des dispositions pour le thread cible pour lever cette exception lorsqu'elle est fermée. La partie la plus délicate sur ce est le thread cible pour lever cette exception.

Les Options 1 et 2 n'a pas de fuite intra-processus de ressources, mais ils se terminent chaque fil.

L'Option 3 ne sera probablement une fuite de ressources, mais est partiellement coopérative en ce que le thread cible doit accepter de jeter l'exception.

Il n'y a pas de mobiles en C++11 (que je connais) à la non-collaboration de tuer un thread unique dans un environnement multi-thread programme (c'est à dire sans les tuer tous les threads). Il n'y a pas de motivation pour la conception d'une telle fonctionnalité.

Un std::thread peut avoir cette fonction de membre:

native_handle_type native_handle();

Vous pourriez être en mesure de l'utiliser pour appeler un OS dépendant de la fonction pour faire ce que vous voulez. Par exemple sur Apple OS, cette fonction existe et native_handle_type est un pthread_t. Si vous avez réussi, vous êtes susceptible de fuite de ressources.

Cette question ont en réalité plus profonde de la nature et de la bonne compréhension du multithreading concepts en général vous donnera un aperçu sur ce sujet. En fait, il n'existe pas de n'importe quelle langue ou de tout système d'exploitation, qui vous offrent des installations pour asynchrones brusquement fin des threads sans avertissement à ne pas les utiliser. Et tous ces environnements d'exécution conseille fortement de développeur ou même avoir besoin de construire des applications multi-thread sur la base de la coopérative ou de l'synchrone fin des threads. La raison pour cela des décisions communes et conseils, tout ce qu'ils sont construits sur la base de la même multithreading modèle.

Nous allons comparer le multitraitement et le multiprocessus concepts afin de mieux comprendre les avantages et les limites de la seconde.

Multitraitement suppose fractionnement de la totalité de l'exécution de l'environnement dans l'ensemble de complètement isolé des processus contrôlés par le système d'exploitation. Le processus intègre et isole de l'environnement d'exécution de l'état, y compris la mémoire locale du processus et des données à l'intérieur et toutes les ressources système comme pour les fichiers, sockets, des objets de synchronisation. L'isolement est une critique caractéristique importante du processus, car il permet de limiter les défauts de la multiplication par le processus de frontières. En d'autres termes, pas un seul processus peut affecte la cohérence de tout autre processus dans le système. Le même est vrai pour le processus de comportement, mais au moins restreints et plus flou manière. Dans un tel environnement tout processus peut être tué à tout "arbitraire" moment, d'abord parce que chaque processus est isolé, d'autre part, le système d'exploitation ont plein de connaissances à propos de toutes les ressources utilisées par les processus et à la libération de tous les d'eux, sans fuite, et, enfin, le processus sera tué par OS pas vraiment dans l'arbitraire moment, mais dans le nombre de points bien définis où l'état du processus est bien connu.

En revanche, le multithreading, suppose l'exécution de plusieurs threads d'un même processus. Mais tout cela threads partagent le même boîtier d'isolation et il n'y a pas de n'importe quel système d'exploitation contrôle de l'état interne du processus. Comme un résultat de n'importe quel thread est en mesure de changer les processus à l'échelle mondiale de l'état ainsi que de corruption. Au même instant, les points sur lesquels l'état du thread est bien connue pour être sûr de tuer un thread dépend entièrement de la logique de l'application et ne sont pas connus ni pour le système d'exploitation, ni pour le langage de programmation de l'exécution. Comme un résultat de filetage du raccordement à l'arbitraire moment les moyens de le tuer au point arbitraire de son chemin d'exécution et peut facilement conduire à des processus à l'échelle de la corruption de données, de la mémoire et des poignées de fuite, des threads, des fuites et des spinlocks et d'autres intra-processus de primitives de synchronisation laissé à l'état fermé empêchant les autres threads de faire des progrès.

À cause de cette approche commune est de forcer les développeurs à mettre en œuvre synchrone ou coopératifs fin des threads, où l'un thread peut demander d'autres thread à la résiliation et à d'autres thread dans bien définis point peut vérifier cette demande et de commencer la procédure d'arrêt de la bien définies de l'état avec la diffusion de l'ensemble global à l'échelle du système des ressources et des processus local de l'ensemble des ressources dans le coffre-fort et de manière cohérente.

Je suppose que le fil qui doit être tué est soit dans n'importe quel type de mode de l'attente, ou faire quelques lourde tâche.
Je voudrais suggérer à l'aide d'un "naïf" façon.

Définir certains globale boolean:

std::atomic_bool stop_thread_1 = false;

Mettre le code suivant (ou similaire) en plusieurs points clés, de sorte qu'elle sera la cause de toutes les fonctions dans la pile d'appel pour le retour jusqu'à ce que le thread se termine naturellement:

if (stop_thread_1)
    return;

Alors arrêter le fil de l'autre (principale) de filetage:

stop_thread_1 = true;
thread1.join ();
stop_thread_1 = false; //(for next time. this can be when starting the thread instead)