python：杀死儿童或报告他们的成功的简单方法？

Question

我想

1. 并行调用 shell 命令（例如下面的“sleep”），
2. 报告它们各自的启动和完成情况，并
3. 能够使用“kill -9parent_process_pid”杀死它们。

已经有很多关于这类事情的文章了，但我觉得我还没有找到我正在寻找的优雅的 pythonic 解决方案。我还试图让那些完全不熟悉 python 的人相对可读（并且简短）。

到目前为止，我的方法（参见下面的代码）是：

1. 将 subprocess.call(unix_command) 放入报告命令的开始和完成的包装函数中。
2. 使用 multiprocess.Process 调用包装函数。
3. 跟踪适当的 pid，将它们全局存储，并在 signal_handler 中杀死它们。

我试图避免使用定期轮询进程的解决方案，但我不确定为什么。

有更好的方法吗？

import subprocess,multiprocessing,signal
import sys,os,time

def sigterm_handler(signal, frame):
        print 'You killed me!'
        for p in pids:
                os.kill(p,9)
        sys.exit(0)

def sigint_handler(signal, frame):
        print 'You pressed Ctrl+C!'
        sys.exit(0)

signal.signal(signal.SIGINT, sigint_handler)
signal.signal(signal.SIGTERM, sigterm_handler)

def f_wrapper(d):
        print str(d) + " start"
        p=subprocess.call(["sleep","100"])
        pids.append(p.pid)
        print str(d) + " done"

print "Starting to run things."

pids=[]

for i in range(5):
        p=multiprocessing.Process(target=f_wrapper,args=(i,))
        p.daemon=True
        p.start()

print "Got things running ..."

while pids:
        print "Still working ..."
        time.sleep(1)

Answer 1

一旦 subprocess.call 返回，子流程已完成 - call 的返回值是子流程的 returncode。因此，将这些返回代码累积在列表 pids 中（顺便说一句，附加它的多进程与“主”进程之间不同步）并向它们发送 9 信号”就好像“它们是进程 ID 而不是返回代码，这绝对是错误的。

这个问题的另一件事肯定是错误的，那就是规范：

能够用“kill -9”杀死他们
Parent_process_pid'。

因为 -9 意味着父进程不可能拦截该信号（这就是显式指定 -9 的目的）——我想因此，这里的 -9 是虚假的。

您应该使用线程而不是多处理（每个“保姆”线程或进程基本上除了等待其子进程之外什么都不做，那么为什么要在这样的进程上浪费进程呢？轻量级任务？-);您还应该在主线程中调用 suprocess.Process （以启动子进程并能够获取其 .pid 放入列表中）并传递生成的进程对象传递给等待它的保姆线程（当它完成时报告并将其从列表中删除）。子进程 ID 列表应该由锁保护，因为主线程和几个保姆线程都可以访问它，并且集合可能是比列表更好的选择（更快的删除），因为您不关心排序也不关心关于避免重复。

所以，粗略地（没有测试，所以可能存在错误；-）我会将您的代码更改为：

import subprocess, threading, signal
import sys, time

pobs = set()
pobslock = threading.Lock()
def numpobs():
    with pobslock:
        return len(pobs)

def sigterm_handler(signal, frame):
    print 'You killed me!'
    with pobslock:
        for p in pobs: p.kill()
    sys.exit(0)

def sigint_handler(signal, frame):
    print 'You pressed Ctrl+C!'
    sys.exit(0)

signal.signal(signal.SIGINT, sigint_handler)
signal.signal(signal.SIGTERM, sigterm_handler)

def f_wrapper(d, p):
    print d, 'start', p.pid
    rc = p.wait()
    with pobslock:
        pobs.remove(p)
    print d, 'done, rc =', rc

print "Starting to run things."

for i in range(5):
    p = subprocess.Popen(['sleep', '100'])
    with pobslock:
        pobs.add(p)
    t = threading.Thread(target=f_wrapper, args=(i, p))
    t.daemon=True
    t.start()

print "Got things running ..."

while numpobs():
    print "Still working ..."
    time.sleep(1)

Answer 2

这段代码（下面的代码）似乎对我有用，可以从命令行中通过“top”或 ctrl-c 进行终止。 Alex 建议中唯一真正的改变是用 subprocess.Popen 调用替换 subprocess.Process （我不认为 subprocess.Process 存在）。

这里的代码也可以通过某种方式锁定标准输出来改进，这样就不会在进程之间打印重叠。

import subprocess, threading, signal
import sys, time

pobs = set()                            # set to hold the active-process objects
pobslock = threading.Lock()     # a Lock object to make sure only one at a time can modify pobs

def numpobs():
        with pobslock:
                return len(pobs)

# signal handlers
def sigterm_handler(signal, frame):
        print 'You killed me! I will take care of the children.'
        with pobslock:
                for p in pobs: p.kill()
        sys.exit(0)

def sigint_handler(signal, frame):
        print 'You pressed Ctrl+C! The children will be dealt with automatically.'
        sys.exit(0)

signal.signal(signal.SIGINT, sigint_handler)
signal.signal(signal.SIGTERM, sigterm_handler)


# a function to watch processes
def p_watch(d, p):
        print d, 'start', p.pid
        rc = p.wait()
        with pobslock:
                pobs.remove(p)
        print d, 'done, rc =', rc


# the main code
print "Starting to run things ..."
for i in range(5):
        p = subprocess.Popen(['sleep', '4'])
        with pobslock:
                pobs.add(p)
        # create and start a "daemon" to watch and report the process p.
        t = threading.Thread(target=p_watch, args=(i, p))
        t.daemon=True
        t.start()

print "Got things running ..."
while numpobs():
        print "Still working ..."
        time.sleep(1)