我目前正在使用subprocess.Popen(cmd, shell=TRUE)来启动一个程序。
我对Python还比较新，但感觉应该有一些API可以让我做类似以下操作的事情：
subprocess.Popen(cmd, shell=TRUE, postexec_fn=function_to_call_on_exit)
function_to_call_on_exit 能够根据 cmd 已经退出的情况做一些事情（例如，记录当前运行的外部进程数）。我认为我可以相对简单地将 subprocess 封装在一个类中，将线程与 Popen.wait() 方法结合起来，但由于我还没有在 Python 中做过线程操作，而且似乎这种情况很常见，有可能已经存在相应的 API，所以我想先尝试找到它。提前感谢您的帮助 :)你说得对 - 没有针对此的好的API。你的第二点也是正确的 - 使用线程轻松设计一个可以为您执行此操作的函数。
import threading
import subprocess
def popen_and_call(on_exit, popen_args):
"""
Runs the given args in a subprocess.Popen, and then calls the function
on_exit when the subprocess completes.
on_exit is a callable object, and popen_args is a list/tuple of args that
would give to subprocess.Popen.
"""
def run_in_thread(on_exit, popen_args):
proc = subprocess.Popen(*popen_args)
proc.wait()
on_exit()
return
thread = threading.Thread(target=run_in_thread, args=(on_exit, popen_args))
thread.start()
# returns immediately after the thread starts
return thread
即使在Python中，线程编程也是非常容易的，但请注意，如果on_exit()计算成本很高，您将需要使用multiprocessing将其放入单独的进程中（以便GIL不会拖慢程序）。实际上非常简单 - 您基本上只需要将所有调用threading.Thread替换为multiprocessing.Process，因为它们遵循（几乎）相同的API。
Python 3.2有一个名为concurrent.futures的模块（对于旧版Python < 3.2，可通过pip install futures获得）：
pool = Pool(max_workers=1)
f = pool.submit(subprocess.call, "sleep 2; echo done", shell=True)
f.add_done_callback(callback)
回调函数将在调用f.add_done_callback()的同一进程中被调用。
import logging
import subprocess
# to install run `pip install futures` on Python <3.2
from concurrent.futures import ThreadPoolExecutor as Pool
info = logging.getLogger(__name__).info
def callback(future):
if future.exception() is not None:
info("got exception: %s" % future.exception())
else:
info("process returned %d" % future.result())
def main():
logging.basicConfig(
level=logging.INFO,
format=("%(relativeCreated)04d %(process)05d %(threadName)-10s "
"%(levelname)-5s %(msg)s"))
# wait for the process completion asynchronously
info("begin waiting")
pool = Pool(max_workers=1)
f = pool.submit(subprocess.call, "sleep 2; echo done", shell=True)
f.add_done_callback(callback)
pool.shutdown(wait=False) # no .submit() calls after that point
info("continue waiting asynchronously")
if __name__=="__main__":
main()
$ python . && python3 .
0013 05382 MainThread INFO begin waiting
0021 05382 MainThread INFO continue waiting asynchronously
done
2025 05382 Thread-1 INFO process returned 0
0007 05402 MainThread INFO begin waiting
0014 05402 MainThread INFO continue waiting asynchronously
done
2018 05402 Thread-1 INFO process returned 0
QProcess.finished()显示了一个示例，说明如何高效地完成此操作，并提供简单的可移植API。 - jfs我修改了Daniel G的答案，简单地将subprocess.Popen中的args和kwargs直接传递而不是作为一个单独的元组/列表，因为我想要在subprocess.Popen中使用关键字参数。
在我的情况下，我有一个方法postExec()，我想在subprocess.Popen('exe', cwd=WORKING_DIR)之后运行它。
有了以下代码，它就变成了popenAndCall(postExec, 'exe', cwd=WORKING_DIR)
import threading
import subprocess
def popenAndCall(onExit, *popenArgs, **popenKWArgs):
"""
Runs a subprocess.Popen, and then calls the function onExit when the
subprocess completes.
Use it exactly the way you'd normally use subprocess.Popen, except include a
callable to execute as the first argument. onExit is a callable object, and
*popenArgs and **popenKWArgs are simply passed up to subprocess.Popen.
"""
def runInThread(onExit, popenArgs, popenKWArgs):
proc = subprocess.Popen(*popenArgs, **popenKWArgs)
proc.wait()
onExit()
return
thread = threading.Thread(target=runInThread,
args=(onExit, popenArgs, popenKWArgs))
thread.start()
return thread # returns immediately after the thread starts
multiprocessing.Pool 解决了它。其中有两个技巧：
def sub(arg):
print arg #prints [1,2,3,4,5]
return "hello"
def cb(arg):
print arg # prints "hello"
pool = multiprocessing.Pool(1)
rval = pool.map_async(sub,([[1,2,3,4,5]]),callback =cb)
(do stuff)
pool.close()
在我的情况下，我希望调用也是非阻塞的。这样做效果非常好。
我受到Daniel G.答案的启发，实现了一个非常简单的用例 - 在我的工作中，我经常需要使用不同的参数重复调用相同的(外部)进程。我曾经黑客式地确定每个特定调用何时完成，但现在我有了更清晰的方式来发出回调。
我喜欢这个实现，因为它非常简单，但它允许我对多个处理器发出异步调用(请注意我使用multiprocessing而不是threading)并在完成时接收通知。
我测试了示例程序，效果很好。请随意编辑并提供反馈。
import multiprocessing
import subprocess
class Process(object):
"""This class spawns a subprocess asynchronously and calls a
`callback` upon completion; it is not meant to be instantiated
directly (derived classes are called instead)"""
def __call__(self, *args):
# store the arguments for later retrieval
self.args = args
# define the target function to be called by
# `multiprocessing.Process`
def target():
cmd = [self.command] + [str(arg) for arg in self.args]
process = subprocess.Popen(cmd)
# the `multiprocessing.Process` process will wait until
# the call to the `subprocess.Popen` object is completed
process.wait()
# upon completion, call `callback`
return self.callback()
mp_process = multiprocessing.Process(target=target)
# this call issues the call to `target`, but returns immediately
mp_process.start()
return mp_process
if __name__ == "__main__":
def squeal(who):
"""this serves as the callback function; its argument is the
instance of a subclass of Process making the call"""
print "finished %s calling %s with arguments %s" % (
who.__class__.__name__, who.command, who.args)
class Sleeper(Process):
"""Sample implementation of an asynchronous process - define
the command name (available in the system path) and a callback
function (previously defined)"""
command = "./sleeper"
callback = squeal
# create an instance to Sleeper - this is the Process object that
# can be called repeatedly in an asynchronous manner
sleeper_run = Sleeper()
# spawn three sleeper runs with different arguments
sleeper_run(5)
sleeper_run(2)
sleeper_run(1)
# the user should see the following message immediately (even
# though the Sleeper calls are not done yet)
print "program continued"
示例输出：
program continued
finished Sleeper calling ./sleeper with arguments (1,)
finished Sleeper calling ./sleeper with arguments (2,)
finished Sleeper calling ./sleeper with arguments (5,)
sleeper.c的源代码，这是我示例的“耗时”外部进程。#include<stdlib.h>
#include<unistd.h>
int main(int argc, char *argv[]){
unsigned int t = atoi(argv[1]);
sleep(t);
return EXIT_SUCCESS;
}
编译为：
gcc -o sleeper sleeper.c
感谢大家指引我正确的方向。我从这里找到了相关的内容并制作了一个类，并添加了一个停止函数来终止该进程：
class popenplus():
def __init__(self, onExit, *popenArgs, **popenKWArgs):
thread = Thread(target=self.runInThread, args=(onExit, popenArgs, popenKWArgs))
thread.start()
def runInThread(self, onExit, popenArgs, popenKWArgs):
self.proc = Popen(*popenArgs, **popenKWArgs)
self.proc.wait()
self.proc = None
onExit()
def stop(self):
if self.proc:
self.proc.kill()
import os
import select
import subprocess
import threading
import weakref
def _close_and_join(fd, thread):
os.close(fd)
thread.join()
def _run_poll_callbacks(quitfd, poll, callbacks):
poll.register(quitfd, select.POLLHUP)
while True:
for fd, event in poll.poll(1000.0):
poll.unregister(fd)
if fd == quitfd:
return
callback = callbacks.pop(fd)
if callback is not None:
callback()
class PollProcs:
def __init__(self):
self.poll = select.poll()
self.callbacks = {}
self.closed = False
r, w = os.pipe()
self.thread = threading.Thread(
target=_run_poll_callbacks, args=(r, self.poll, self.callbacks)
)
self.thread.start()
self.finalizer = weakref.finalize(self, _close_and_join, w, self.thread)
def run(self, cmd, callback=None):
if self.closed:
return
r, w = os.pipe()
self.callbacks[r] = callback
self.poll.register(r, select.POLLHUP)
popen = subprocess.Popen(cmd, pass_fds=(w,))
os.close(w)
print("running", " ".join(cmd), "as", popen.pid)
return popen
def main():
procs = PollProcs()
for i in range(3, 0, -1):
procs.run(["sleep", str(i)], callback=lambda i=i: print(f"sleep {i} done?"))
import time
print("Waiting...")
time.sleep(3)
if __name__ == "__main__":
main()
select.epoll可能是一个更好的选择，因为它允许更新正在进行的轮询。import signal
import subprocess
def sigchld_handler(signum, frame):
# This is run when the child exits.
# Do something here ...
pass
signal.signal(signal.SIGCHLD, sigchld_handler)
process = subprocess.Popen('mycmd', shell=TRUE)
subprocess模块中没有这样的API。你需要自己编写一些代码，可能需要使用线程来实现。