Python tuer le fil

Bien que nous ne puissions pas tuer les threads en python, il existe quelques techniques que nous pouvons utiliser pour simuler la mort de fil à Python. Tuer un fil à Python soudainement est considéré comme une mauvaise approche de programmation car nous ne pouvons pas tuer directement le fil. Au lieu de cela, nous devons utiliser l'une des méthodes fournies par Python. Ces méthodes termineront avec précision les fils, mais ils sont assez proches du processus.

Créer un fil dans Python

Lorsque vous exécutez un programme, un thread est un flux d'exécution séparé qui s'exécute en arrière-plan du programme. Les fils Python sont un type de processus qui peut faire planifier leur exécution. Un fil est, pour le dire simplement, un processus informatique qu'un ordinateur réalisera. L'ensemble d'instructions d'un programme peut être effectué séparément des autres codes. Le thread d'arrière-plan ne peut pas être correctement terminé en python, mais il existe d'autres techniques que nous pouvons utiliser si nous souhaitons toujours terminer le fil. Ces méthodes ne terminent cependant pas correctement le fil; ils ne sont plutôt très utiles que pour le faire. Mais ici, nous allons d'abord montrer comment démarrer un fil avant de vous montrer comment l'arrêter.

Exécutons le code. Tout d'abord, nous importons les bibliothèques «Time» et «Thread». Ensuite, dans la ligne suivante, nous définissons la fonction «Func1». Dans la ligne suivante, nous utilisons une boucle pour démarrer la variable «x» et définissez la plage pour les itérations du thread. Ici, nous définissons la plage de «1» à «10», ce qui signifie que notre fil s'arrêtera après «10» itérations. Dans la ligne suivante, nous appelons «le temps.Sleep (), "avec un intervalle de temps de" 1 ". Nous avons utilisé le «temps.Fonction sleep () ”Lorsque nous voulions retarder l'exécution d'une déclaration.

Ensuite, nous avons appelé la fonction print () à l'intérieur de cette fonction. Nous avons passé la variable «X», dans laquelle le nombre d'itérations a été stocké et a également réussi l'instruction d'entrée, «terminées itérations avant de quitter». Au fur et à mesure que nous définissons le temps sur «1», le système passera en mode sommeil pour «1» avant d'imprimer la déclaration d'impression. Ensuite, dans la ligne suivante, nous appelons cette fonction «Func» avec le module «Thread». Ici, nous avons initialisé la variable «T» pour stocker du fil dedans. Ensuite, nous utilisons le «T.Fonction start () ”pour démarrer le thread. Et nous appelons la fonction «join ()» avec le thread La méthode «join ()» suspend la mise en œuvre d'un programme jusqu'à ce que le thread de destination soit lu dans son intégralité.

Une fois le thread, ses itérations «10», le système suscitera son fonctionnement pour «1» en seconde avant l'impression de l'expression «itérations terminées avant de quitter."Maintenant, lorsque nous appelons la fonction avec du thread, elle commencera l'exécution du thread alors que nous définissons au-dessus de la boucle et sa plage est" 10 ".

Maintenant qu'il a montré toutes ses itérations dans la sortie, il est impossible de tuer le fil ici. Lorsque nous cliquez sur CTRL-C après un certain nombre d'itérations, le fil continuera à fonctionner jusqu'à ce que toutes ses itérations soient terminées. Ce fil comprend simplement qu'il doit terminer ses itérations «10».

Utilisation du fil de démon pour tuer le fil

Maintenant, nous ne pouvons pas tuer le fil en utilisant cette méthode. Cependant, nous pouvons empêcher le thread de terminer en utilisant cette méthode en terminant simplement son exécution après un temps défini, le fil n'est pas arrêté dans le backend. Les fils de base en arrière-plan qui prennent en continu les fils primaires ou non-non-objets en fonctionnant au premier plan sont appelés fils de démon. Le fil de démon qui s'exécute en arrière-plan n'empêche pas le fil de mourir.

Commençons le code en important trois bibliothèques: le «threading» est le premier, suivi respectivement «Time» et «Sys». De nombreuses méthodes et variables dans le package Python Sys peuvent être utilisées pour modifier différents composants du système d'exploitation Python. Travailler sur l'interprète est rendu possible par son accessibilité aux constantes et aux méthodes qui ont une connexion étroite avec l'interprète. Suite à la création d'une fonction avec le nom «Func», nous avons utilisé une condition «True» pour travailler conditionnellement jusqu'à ce que l'instruction soit exécutée à l'intérieur de la boucle.

Ensuite, dans la ligne suivante, nous avons utilisé la fonction «print ()» pour imprimer la phrase, «le thread est actif mais disparaîtra à la fin du programme», après avoir passé le temps «1» seconde dans le «temps.Fonction sleep () ”. Comme nous avons utilisé «le temps.Sleep () ”ci-dessus pour définir le temps sur« 1 »secondes, l'instruction entrera désormais en mode sommeil pendant une seconde avant de produire cette méthode. Ensuite, dans la ligne suivante, nous utilisons le démon et sa propriété pour «vrai» pour nous permettre de mettre fin à nos fils après un temps prédéterminé.

Actuellement, nous générons un thread en utilisant «Threading.thread ”et utiliser« Target = func »pour appeler la fonction dans le thread. Maintenant que nous avons utilisé «t.start () ”Pour démarrer notre fil, nous avons appelé« sys.exit () », qui amènera le système à lancer une exception de sortie du système. Donc, ce que ce code fait vraiment, c'est afficher la déclaration d'impression qui a été enregistrée dans la fonction «Func» lorsque le thread l'appelle, mais il retarde l'impression de la déclaration en «1» secondes parce que nous avons utilisé «Time.dormir()."

Comme vous pouvez le voir, le fil est actuellement en cours d'exécution, mais lorsqu'il était sur le point de terminer sa huitième itération, nous avons pressé Ctrl-C, ce qui a immédiatement arrêté la terminaison du fil. Cela signifie essentiellement qu'en utilisant un fil de démon, nous n'avons pas pu réellement tuer le fil, seulement pour l'empêcher de courir. Ce n'est pas la façon la plus efficace de mettre fin au fil; Au lieu de cela, nous devons mettre fin à l'ensemble de l'opération.

Puisqu'il n'est pas possible de forcer le fil à se terminer en l'interrompant avec le clavier, nous utilisons maintenant l'objet Python Events dans le script suivant. Cela entraînera l'arrêt du fil tout seul. Nous n'avons pas besoin de frapper des clés pour l'empêcher de terminer. Cet objet d'événement est proposé dans le module de thread. Il a deux méthodes spécifiées: set () et non set ().

Commençons par implémenter le code en important les packages «signal», «filetage» et «temps». La ligne suivante utilise ensuite «Threading.event () ”pour invoquer l'événement du fil. Ensuite, dans la ligne suivante, nous utilisons la fonction d'impression () et à l'intérieur, nous appelons l'instruction d'entrée en passant l'argument «i de 20 itérations.«Nous imprimons la valeur de« I »dans la variable« F », qui est des itérations« 20 ». Ensuite, dans la ligne suivante, nous utilisons une boucle pour la boucle et à l'intérieur, nous créons la variable «i» et définissons la plage sur «1» sur «20». Ensuite, nous avons utilisé la condition «IF» qui est la sortie.événement.est set () Il casse la boucle, ce qui signifie que si l'événement est défini (), puis se termine. Nous utilisons la fonction print () pour imprimer l'instruction qui est «Itérations terminées avant de sortir» et imprimer la valeur «I» dans la variable «F». Nous avons utilisé la condition «IF» qui est la sortie .événement.est défini () puis cassez la boucle.

Ensuite, nous avons créé une nouvelle fonction avec le nom «Handler de signal» auquel nous avons passé les variables «Signum» et «Frame». Après avoir utilisé l'Exit_event.set (), nous avons appelé les fonctions «gestionnaire de signaux» avec signal.signal et fonction «func» avec «filetage.thread ", respectivement. Enfin, nous avons utilisé la fonction join () à la fin pour connecter les deux fonctions.

Comme vous pouvez le voir dans l'affichage des résultats, nous définissons la plage sur «20», ce qui indique que le calcul se terminera après vingt itérations, mais dans ce cas, il s'est terminé après cinq itérations même si nous n'avons cliqué aucune touche d'interruption du clavier. Cela indique que le fil n'a pas été tué mais plutôt terminé, ce qui est bénéfique pour la présentation.

Conclusion

Dans cet article, nous avons discuté de la façon de tuer un fil dans Python, cependant, nous avons découvert que même si nous pouvons arrêter l'exécution d'un fil après un certain nombre d'itérations, nous ne pouvons pas tuer un fil dans Python. Nous avons d'abord créé un fil, puis utilisé un fil de démon pour le tuer. Néanmoins, nous avons constaté qu'en utilisant ce module, nous pourrions immédiatement arrêter l'exécution du thread en tapant Ctrl-C, et le fil ne serait pas tué. Le fil sera instantanément arrêté après une certaine exécution lorsque nous avons utilisé des objets d'événement Python, ce qui a été utile.