comment tuer (ou à éviter) zombie processus sous-processus module

Un zombie n'est pas un processus réel, c'est juste un reste d'entrée dans le processus de la table jusqu'à ce que le processus parent demande à l'enfant de code de retour. Le processus a pris fin et ne nécessite pas d'autres ressources, mais a déclaré processus d'entrée de la table.

Nous avons probablement besoin de plus d'informations sur le processus à exécuter dans afin de les aider réellement plus.

Toutefois, dans le cas où votre programme en Python sait lorsque le processus enfants ont pris fin (par exemple, en atteignant la fin de l'enfant stdout de données), vous pouvez appeler en toute sécurité process.wait():

import subprocess

process= subprocess.Popen( ('ls', '-l', '/tmp'), stdout=subprocess.PIPE)

for line in process.stdout:
        pass

subprocess.call( ('ps', '-l') )
process.wait()
print "after wait"
subprocess.call( ('ps', '-l') )

Exemple de sortie:

$ python so2760652.py
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 S   501 21328 21326  0  80   0 -  1574 wait   pts/2    00:00:00 bash
0 S   501 21516 21328  0  80   0 -  1434 wait   pts/2    00:00:00 python
0 Z   501 21517 21516  0  80   0 -     0 exit   pts/2    00:00:00 ls <defunct>
0 R   501 21518 21516  0  80   0 -   608 -      pts/2    00:00:00 ps
after wait
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 S   501 21328 21326  0  80   0 -  1574 wait   pts/2    00:00:00 bash
0 S   501 21516 21328  0  80   0 -  1467 wait   pts/2    00:00:00 python
0 R   501 21519 21516  0  80   0 -   608 -      pts/2    00:00:00 ps

Sinon, vous pouvez garder tous les enfants dans une liste, et maintenant et puis .poll pour leurs codes de retour. Après chaque itération, n'oubliez pas de retirer de la liste des enfants avec des codes de retour différent de None (c'est à dire le fini de celles).

Si vous utilisez simplement subprocess.Popen, vous serez bien - voici comment:

import subprocess

def spawn_some_children():
    subprocess.Popen(["sleep", "3"])
    subprocess.Popen(["sleep", "3"])
    subprocess.Popen(["sleep", "3"])

def do_some_stuff():
    spawn_some_children()
    # do some stuff
    print "children went out to play, now I can do my job..."
    # do more stuff

if __name__ == '__main__':
    do_some_stuff()

Vous pouvez utiliser .poll() de l'objet retourné par Popen pour vérifier si il fini (sans attente). Si elle renvoie None, l'enfant est toujours en cours d'exécution.

Assurez-vous de ne pas garder les références à la Popen objets - si vous le faites, elles ne seront pas nettoyés, si vous vous retrouvez avec des zombies. Voici un exemple:

import subprocess

def spawn_some_children():
    children = []
    children.append(subprocess.Popen(["sleep", "3"]))
    children.append(subprocess.Popen(["sleep", "3"]))
    children.append(subprocess.Popen(["sleep", "3"]))
    return children

def do_some_stuff():
    children = spawn_some_children()
    # do some stuff
    print "children went out to play, now I can do my job..."
    # do more stuff

    # if children finish while we are in this function,
    # they will become zombies - because we keep a reference to them

Dans l'exemple ci-dessus, si vous voulez vous débarrasser des zombies, vous pouvez soit .wait() sur chacun des enfants ou .poll() jusqu'à ce que le résultat n'est pas None.

De toute façon est bien - on ne garde pas les références, ou à l'aide de .wait() ou .poll().

Je ne suis pas sûr de ce que vous voulez dire "j'ai besoin d'exécuter mon script avec no_wait()", mais je pense que cet exemple n'est ce qu'il vous faut. Les processus ne seront pas des zombies pour très longtemps. Le processus parent ne wait() sur eux lorsqu'ils sont en fait déjà terminée et donc ils vont rapidement unzombify.

#!/usr/bin/env python2.6
import subprocess
import sys
import time

children = []
#Step 1: Launch all the children asynchronously
for i in range(10):
    #For testing, launch a subshell that will sleep various times
    popen = subprocess.Popen(["/bin/sh", "-c", "sleep %s" % (i + 8)])
    children.append(popen)
    print "launched subprocess PID %s" % popen.pid

#reverse the list just to prove we wait on children in the order they finish,
#not necessarily the order they start
children.reverse()
#Step 2: loop until all children are terminated
while children:
    #Step 3: poll all active children in order
    children[:] = [child for child in children if child.poll() is None]
    print "Still running: %s" % [popen.pid for popen in children]
    time.sleep(1)

print "All children terminated"

La sortie vers la fin ressemble à ceci:

Still running: [29776, 29774, 29772]
Still running: [29776, 29774]
Still running: [29776]
Still running: []
All children terminated

Récemment, je suis tombé sur ce zombie problème à cause de mon script python. Le problème réel est principalement due à la destruction de la sous-processus et le processus parent ne sait pas que l'enfant est mort. Donc, ce que j'ai fait, juste l'ajout de popen.communiquer() après le signal kill des processus enfant de sorte que le processus parent vient à savoir que l'enfant est mort, puis les mises à jour du noyau le pid du childprocess puisque l'enfant n'est plus et donc il n'y a pas de zombies formé maintenant.

PS:un sondage est également une option ici, car il vérifie et transmet sur le statut de l'enfant au parent. Souvent en sous-processus, il est préférable si u utilisation check_output ou appel si u n'a pas besoin de communiquer avec le stdin, stdout et.