Utilisez du pool de threads pour exécuter simultanément les processus d'enfants pour améliorer l'efficacité

Cet article vise à introduire comment utiliser le module de sous-processus de Python pour exécuter plusieurs sous-processus simultanément et améliorer considérablement l'efficacité d'exécution du programme via des pools de threads. Nous analyserons les scénarios communs à l'aide des méthodes Sub-Process.popen et .Communicate () et fournir un exemple de code pour utiliser Threadpool pour attendre que le processus enfant se termine simultanément.

Lors de l'exécution de plusieurs sous-processus à l'aide du module de sous-processus, une idée fausse commune est que la fonction POPEN bloque l'exécution du programme. En fait, la fonction POPEN n'est pas bloquante et il renverra immédiatement un objet POPEN, permettant au programme de continuer à exécuter. Cependant, la méthode communicate () de l'objet POPEN bloque, ce qui attend que le processus de l'enfant termine l'exécution et renvoie sa sortie. Si la méthode communicate () est appelée en séquence dans une boucle, elle entraînera en fait les processus d'enfants séquentiellement, réduisant ainsi l'efficacité du programme.

Pour résoudre ce problème, un pool de fils peut être utilisé pour attendre simultanément que le processus de l'enfant se termine. Un pool de threads peut créer plusieurs threads, chaque thread est responsable de l'attente d'un processus d'enfant. De cette façon, plusieurs sous-processus peuvent être exécutés simultanément, améliorant ainsi l'efficacité d'exécution du programme.

Voici un exemple de code qui utilise un pool de threads pour attendre simultanément que le processus enfant se termine:

 sous-processus d'importation
journalisation d'importation
à partir de multiprocessement.

Logging.basicConfig (niveau = logging.debug, format = '% (asctime) s -% (niveau) s -% (message) s')
log = logging.getLogger (__ name__)

Def RunshowCommands (CMDTable) -> Dict:
    "" "Renvoie un dictionnaire de sortie capturée des commandes définies dans cmdtable." ""
    procountput = {} # Dict pour stocker le texte de sortie des commandes Show
    prochandles = {}
    Pour CMD, commande dans cmdtable.items ():
        essayer:
            log.debug (f "Sous-processus en cours d'exécution {cmd} - {commande}")
            prochandles [cmd] = sub-process.popen (commande, stdout = sub-process.pipe, stderr = sub-process.pipe, shell = true)
        sauf exception comme e:
            log.Error (f "Erreur Lancement de sous-processus {cmd}: {e}")
            Continuer à continuer

    def handle_proc_stdout (manche):
        essayer:
            proc = prochandles [manche]
            stdout, stderr = procc.communicate (timeout = 180)
            procountput [manche] = stdout.decode ("utf-8") # transformez la partie stdout en texte
            log.debug (f "Sous-processus renvoyé {handle}")
            Si stderr:
                Log.Error (f "Sub-Process {manche} Renvoyé stderr: {stderr.decode ('utf-8')}")
        Sauf Sub-Process.TimeoutExpired:
            Log.Error (f "Sous-processus {manche} timed out")
            proc.kill () # terminer le processus
        sauf exception comme e:
            log.Error (f "Sous-processus de gestion des erreurs {manche}: {e}")


    Threadpool = Threadpool ()
    threadpool.map (handle_proc_stdout, prochandles.keys ())
    threadpool.close ()
    Threadpool.join ()

    Retour ProTutput

Si __Name__ == '__MAIN__':
    cmdTable = {
        'Himom': "Echo Salut maman",
        'Au revoir': "Echo Goodbye",
        'Date': "Date",
        'Sleep': "Sleep 2 && echo dormait"
    }

    Output = RunshowCommands (CMDTable)

    pour CMD, Out in Output.items ():
        print (f "sortie de {cmd}: \ n {out}")

Explication du code:

1. Fonction RunshowCommands (CMDTable):

   • Accepte un dictionnaire cmdtable où la clé est le nom de la commande et la valeur est la chaîne de commande à exécuter.
   • Créez un dictionnaire vide ProCutput pour stocker la sortie de chaque commande.
   • Créez un dictionnaire vide Prochandles pour stocker chaque objet POPEN.
   • Boucle via chaque commande dans CMDTable:
     • Utilisez Sub-Process.popen pour démarrer le processus de l'enfant et rediriger Stdout et Stderr vers le pipeline. shell = true permet une exécution directe des commandes de chaîne, mais faites attention à la sécurité.
     • Store l'objet POPEN dans le dictionnaire Prochandles, la clé est le nom de commande.
   • Définissez une fonction interne Handle_Proc_stdout (manche):
     • Cette fonction est responsable du traitement de la sortie d'un seul processus d'enfant.
     • Utilisez Prochandles [Handle] .ComminiCate (timeout = 180) pour obtenir la sortie du processus de l'enfant et définir le délai d'expiration à 180 secondes.
     • Décodez la sortie dans une chaîne UTF-8 et stockez-la dans le dictionnaire ProTutput.
     • Enregistre les messages renvoyés par le processus de l'enfant.
     • Gérez l'exception de tempsout, si le processus de l'enfant a expiré, une erreur est enregistrée et le processus est terminé.
     • Gérez les autres exceptions et enregistrez un message d'erreur si une autre erreur se produit.
   • Créez un objet Threadpool.
   • Utilisez threadpool.map (handle_proc_stdout, prochandles.keys ()) pour appliquer la fonction handle_proc_stdout à chaque clé (nom de commande) dans le dictionnaire Prochandles. Cela exécute la fonction Handle_Proc_stdout en parallèle dans le pool de threads.
   • Appelez Threadpool.close () pour empêcher que plus de tâches soient soumises au pool de threads.
   • Appelez Threadpool.join () pour attendre que tous les threads se terminent.
   • Renvoie le dictionnaire ProTutput.

2. Si __name__ == '__MAIN__': Bloc:

   • Créez un exemple de dictionnaire CMDTable.
   • Appelez RunshowCommands (CMDTable) pour exécuter la commande et obtenir la sortie.
   • Boucle dans le dictionnaire de sortie et imprimez la sortie de chaque commande.

Notes:

• Traitement du délai d'expiration: Communiquer (Timeout = 180) définit le temps de temps mort pour empêcher le processus de l'enfant de s'exécuter indéfiniment. Si le processus de l'enfant ne se termine pas dans le délai spécifié, une exception de temps à échéance sera augmentée et le processus sera interrompu.
• Gestion des erreurs: le code contient un essai ... sauf le bloc, utilisé pour attraper des exceptions possibles, telles que l'échec ou le délai de démarrage du processus d'enfant.
• Sécurité des threads: assurez-vous que l'accès et la modification des ressources partagées (comme le dictionnaire ProTutput) dans un environnement multi-thread sont en file d'attente. Dans cet exemple, puisque chaque thread écrit une clé différente, le fonctionnement d'écriture du dictionnaire est en filetage.
• Limites des ressources: la création de trop de threads peut consommer beaucoup de ressources système. La taille du pool de threads doit être ajustée en fonction de la nature des ressources et des tâches du système.
• Sécurité: lors de l'exécution de commandes avec shell = true, vous devez faire attention aux risques d'injection de commande. Assurez-vous que la chaîne de commande provient d'une source de confiance ou échappez à l'entrée de manière appropriée.
• Journalisation: utilisez le module de journalisation pour enregistrer l'état de fonctionnement du programme, ce qui est pratique pour le débogage et le dépannage.

Résumer:

En utilisant des pools de threads, plusieurs processus d'enfants peuvent être exécutés simultanément, améliorant ainsi considérablement l'efficacité d'exécution du programme. La mise en commun des threads est une technique très utile lorsqu'il s'agit d'un grand nombre de tâches simultanées. N'oubliez pas de prendre en compte des facteurs tels que le traitement du délai d'attente, la gestion des erreurs, la sécurité des filetages et les contraintes de ressources pour assurer l'exactitude et la stabilité de votre programme.

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!