Explication détaillée de l'exemple de code de pause, de reprise et de sortie du thread Python

Pause, reprise, sortie du thread Python

Nous savons tous que le module de threading en Python peut implémenter le multi-threading, mais le module ne fournit pas de pause , reprendre et Pour arrêter un thread, une fois que l'objet thread appelle la méthode start, il ne peut qu'attendre que la fonction de méthode correspondante soit terminée. En d'autres termes, une fois démarré, le thread est hors de contrôle. Cependant, nous pouvons l'implémenter nous-mêmes. .La méthode générale consiste à boucler Déterminer un bit d'indicateur, et une fois que le bit d'indicateur atteint une valeur prédéterminée, quittez la boucle. De cette façon, le thread peut être quitté. Mais suspendre et reprendre le thread est un peu difficile, et j'ai. Je n'ai trouvé aucune bonne méthode jusqu'à ce que je voie la description de la méthode d'attente de l'objet Event dans le thread

wait([timeout])

  Block until the internal flag is true. If the internal flag is true on entry, return immediately. Otherwise, block until another thread calls set() to set the flag to true, or until the optional timeout occurs.

  阻塞, 直到内部的标志位为True时. 如果在内部的标志位在进入时为True时, 立即返回. 否则, 阻塞直到其他线程调用set()方法将标准位设为True, 或者到达了可选的timeout时间.

  When the timeout argument is present and not None, it should be a floating point number specifying a timeout for the operation in seconds (or fractions thereof).

  This method returns the internal flag on exit, so it will always return True except if a timeout is given and the operation times out.

  当给定了timeout参数且不为None, 它应该是一个浮点数，以秒为单位指定操作的超时（或是分数）。

  此方法在退出时返回内部标志，因此除非给定了超时且操作超时，否则它将始终返回True。

  Changed in version 2.7: Previously, the method always returned None.

  2.7版本以前, 这个方法总会返回None.

Utilisation du mécanisme de blocage d'attente. , vous pouvez faire une pause et reprendre, puis coopérer en boucle pour juger le bit du drapeau, vous pouvez quitter Voici l'exemple de code :

#!/usr/bin/env python
# coding: utf-8

import threading
import time

class Job(threading.Thread):

  def __init__(self, *args, **kwargs):
    super(Job, self).__init__(*args, **kwargs)
    self.__flag = threading.Event()   # 用于暂停线程的标识
    self.__flag.set()    # 设置为True
    self.__running = threading.Event()   # 用于停止线程的标识
    self.__running.set()   # 将running设置为True

  def run(self):
    while self.__running.isSet():
      self.__flag.wait()   # 为True时立即返回, 为False时阻塞直到内部的标识位为True后返回
      print time.time()
      time.sleep(1)

  def pause(self):
    self.__flag.clear()   # 设置为False, 让线程阻塞

  def resume(self):
    self.__flag.set()  # 设置为True, 让线程停止阻塞

  def stop(self):
    self.__flag.set()    # 将线程从暂停状态恢复, 如何已经暂停的话
    self.__running.clear()    # 设置为False

Ce qui suit est le. code de test :

a = Job()
a.start()
time.sleep(3)
a.pause()
time.sleep(3)
a.resume()
time.sleep(3)
a.pause()
time.sleep(2)
a.stop()

Résultats du test :




Ceci complète les fonctions de pause, de reprise et arrêter. Mais il y a un inconvénient ici : qu'il soit en pause ou L'arrêt n'est pas instantané, et il doit attendre que l'opération à l'intérieur de la fonction run atteigne le jugement du drapeau. En d'autres termes, l'opération sera en retard une fois.
Mais ce n'est pas nécessairement une mauvaise chose parfois. Si la fonction d'exécution implique des opérations de fichier ou de base de données, etc., puis quittez-la après l'avoir exécutée complètement, vous pouvez à la place exécuter le code pour les opérations de libération de ressources restantes (telles que diverses opérations). ferme). Il n'y aura pas d'embarras tels que les opérateurs de fichiers du programme dépassant la limite supérieure et la situation de connexion à la base de données qui ne sera pas libérée.

Merci d'avoir lu, j'espère que cela pourra aider tout le monde, merci à tous. votre soutien à ce site !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!