Python多处理 - AssertionError：只能加入子进程

Question

我第一次尝试使用 python 多处理模块，但遇到了一些问题。我对线程模块非常熟悉，但我需要确保我正在执行的进程是并行运行的。

这是我正在尝试做的事情的概要。请忽略未声明的变量/函数之类的内容，因为我无法完整粘贴我的代码。

import multiprocessing
import time

def wrap_func_to_run(host, args, output):
    output.append(do_something(host, args))
    return

def func_to_run(host, args):
    return do_something(host, args)

def do_work(server, client, server_args, client_args):
    server_output = func_to_run(server, server_args)
    client_output = func_to_run(client, client_args)
    #handle this output and return a result
    return result

def run_server_client(server, client, server_args, client_args, server_output, client_output):
    server_process = multiprocessing.Process(target=wrap_func_to_run, args=(server, server_args, server_output))
    server_process.start()  
    client_process = multiprocessing.Process(target=wrap_func_to_run, args=(client, client_args, client_output))
    client_process.start()
    server_process.join()
    client_process.join()
    #handle the output and return some result    

def run_in_parallel(server, client):
    #set up commands for first process
    server_output = client_output = []
    server_cmd = "cmd"
    client_cmd = "cmd"
    process_one = multiprocessing.Process(target=run_server_client, args=(server, client, server_cmd, client_cmd, server_output, client_output))
    process_one.start()
    #set up second process to run - but this one can run here
    result = do_work(server, client, "some server args", "some client args")
    process_one.join()
    #use outputs above and the result to determine result
    return final_result

def main():
    #grab client
    client = client()
    #grab server
    server = server()
    return run_in_parallel(server, client)

if __name__ == "__main__":
    main()

这是我得到的错误：

Error in sys.exitfunc:
Traceback (most recent call last):
  File "/usr/lib64/python2.7/atexit.py", line 24, in _run_exitfuncs
    func(*targs, **kargs)
  File "/usr/lib64/python2.7/multiprocessing/util.py", line 319, in _exit_function
    p.join()
  File "/usr/lib64/python2.7/multiprocessing/process.py", line 143, in join
    assert self._parent_pid == os.getpid(), 'can only join a child process'
AssertionError: can only join a child process

我尝试了很多不同的方法来解决这个问题，但我的感觉是我使用这个模块的方式有问题。

编辑：

所以我创建了一个文件，该文件将通过模拟客户端/服务器及其所做的工作来重现这一点 - 我也错过了一个重要的点，那就是我在 unix 中运行它。另一个重要的信息是do_work 在我的实际案例中涉及使用os.fork()。如果不使用os.fork()，我将无法重现该错误，所以我假设问题就在那里。在我的真实案例中，那部分代码不是我的，所以我把它当作一个黑匣子（可能是我的错误）。无论如何，这里是重现的代码 -

#!/usr/bin/python

import multiprocessing
import time
import os
import signal
import sys

class Host():
    def __init__(self):
        self.name = "host"

    def work(self):
        #override - use to simulate work
        pass

class Server(Host):
    def __init__(self):
        self.name = "server"

    def work(self):
        x = 0
        for i in range(10000):
            x+=1
        print x
        time.sleep(1)

class Client(Host):
    def __init__(self):
        self.name = "client"

    def work(self):
        x = 0
        for i in range(5000):
            x+=1
        print x
        time.sleep(1)

def func_to_run(host, args):
    print host.name + " is working"
    host.work()
    print host.name + ": " + args
    return "done"

def do_work(server, client, server_args, client_args):
    print "in do_work"
    server_output = client_output = ""
    child_pid = os.fork()
    if child_pid == 0:
        server_output = func_to_run(server, server_args)
        sys.exit(server_output)
    time.sleep(1)

    client_output = func_to_run(client, client_args)
    # kill and wait for server to finish
    os.kill(child_pid, signal.SIGTERM)
    (pid, status) = os.waitpid(child_pid, 0)

    return (server_output == "done" and client_output =="done")

def run_server_client(server, client, server_args, client_args):
    server_process = multiprocessing.Process(target=func_to_run, args=(server, server_args))
    print "Starting server process"
    server_process.start()
    client_process = multiprocessing.Process(target=func_to_run, args=(client, client_args))
    print "Starting client process"
    client_process.start()
    print "joining processes"
    server_process.join()
    client_process.join()
    print "processes joined and done"

def run_in_parallel(server, client):
    #set up commands for first process
    server_cmd = "server command for run_server_client"
    client_cmd = "client command for run_server_client"
    process_one = multiprocessing.Process(target=run_server_client, args=(server, client, server_cmd, client_cmd))
    print "Starting process one"
    process_one.start()
    #set up second process to run - but this one can run here
    print "About to do work"
    result = do_work(server, client, "server args from do work", "client args from do work")
    print "Joining process one"
    process_one.join()
    #use outputs above and the result to determine result
    print "Process one has joined"
    return result

def main():
    #grab client
    client = Client()
    #grab server
    server = Server()
    return run_in_parallel(server, client)

if __name__ == "__main__":
    main()

如果我在do_work 中删除os.fork() 的使用，我不会收到错误，并且代码的行为就像我之前预期的那样（除了传递我已经接受为我的错误的输出/误解）。我可以将旧代码更改为不使用 os.fork() 但我也想知道为什么会导致此问题以及是否有可行的解决方案。

编辑 2：

我开始研究在接受答案之前省略 os.fork() 的解决方案。这是我对可以完成的模拟工作量的一些调整 -

#!/usr/bin/python

import multiprocessing
import time
import os
import signal
import sys
from Queue import Empty

class Host():
    def __init__(self):
        self.name = "host"

    def work(self, w):
        #override - use to simulate work
        pass

class Server(Host):
    def __init__(self):
        self.name = "server"

    def work(self, w):
        x = 0
        for i in range(w):
            x+=1
        print x
        time.sleep(1)

class Client(Host):
    def __init__(self):
        self.name = "client"

    def work(self, w):
        x = 0
        for i in range(w):
            x+=1
        print x
        time.sleep(1)

def func_to_run(host, args, w, q):
    print host.name + " is working"
    host.work(w)
    print host.name + ": " + args
    q.put("ZERO")
    return "done"

def handle_queue(queue):
    done = False
    results = []
    return_val = 0
    while not done:
        #try to grab item from Queue
        tr = None
        try:
            tr = queue.get_nowait()
            print "found element in queue"
            print tr
        except Empty:
            done = True
        if tr is not None:
            results.append(tr)
    for el in results:
        if el != "ZERO":
            return_val = 1
    return return_val

def do_work(server, client, server_args, client_args):
    print "in do_work"
    server_output = client_output = ""
    child_pid = os.fork()
    if child_pid == 0:
        server_output = func_to_run(server, server_args)
        sys.exit(server_output)
    time.sleep(1)

    client_output = func_to_run(client, client_args)
    # kill and wait for server to finish
    os.kill(child_pid, signal.SIGTERM)
    (pid, status) = os.waitpid(child_pid, 0)

    return (server_output == "done" and client_output =="done")



def run_server_client(server, client, server_args, client_args, w, mq):
    local_queue = multiprocessing.Queue()
    server_process = multiprocessing.Process(target=func_to_run, args=(server, server_args, w, local_queue))
    print "Starting server process"
    server_process.start()
    client_process = multiprocessing.Process(target=func_to_run, args=(client, client_args, w, local_queue))
    print "Starting client process"
    client_process.start()
    print "joining processes"
    server_process.join()
    client_process.join()
    print "processes joined and done"
    if handle_queue(local_queue) == 0:
        mq.put("ZERO")

def run_in_parallel(server, client):
    #set up commands for first process
    master_queue = multiprocessing.Queue()
    server_cmd = "server command for run_server_client"
    client_cmd = "client command for run_server_client"
    process_one = multiprocessing.Process(target=run_server_client, args=(server, client, server_cmd, client_cmd, 400000000, master_queue))
    print "Starting process one"
    process_one.start()
    #set up second process to run - but this one can run here
    print "About to do work"
    #result = do_work(server, client, "server args from do work", "client args from do work")
    run_server_client(server, client, "server args from do work", "client args from do work", 5000, master_queue)
    print "Joining process one"
    process_one.join()
    #use outputs above and the result to determine result
    print "Process one has joined"
    return_val = handle_queue(master_queue)
    print return_val
    return return_val

def main():
    #grab client
    client = Client()
    #grab server
    server = Server()
    val = run_in_parallel(server, client)
    if val:
        print "failed"
    else:
        print "passed"
    return val

if __name__ == "__main__":
    main()

此代码有一些经过调整的打印输出，只是为了准确了解正在发生的事情。我使用 multiprocessing.Queue 跨进程存储和共享输出，然后返回到我的主线程进行处理。我认为这解决了我的问题的 python 部分，但我正在处理的代码中仍然存在一些问题。我唯一能说的另一件事是，相当于func_to_run 涉及通过 ssh 发送命令并抓取任何错误以及输出。出于某种原因，这对于执行时间较短的命令非常有效，但对于执行时间/输出较大的命令则效果不佳。我尝试在此处的代码中使用截然不同的工作值来模拟这一点，但无法重现类似的结果。

编辑 3 我正在使用的库代码（同样不是我的）使用 Popen.wait() 来执行 ssh 命令，我刚刚读到：

Popen.wait() 等待子进程终止。设置并返回返回码属性。

警告这将在使用 stdout=PIPE 和/或 stderr=PIPE 时发生死锁，并且 >child 进程向管道生成足够的输出，从而阻塞等待 >OS 管道缓冲区接受更多数据。使用communicate() 来避免这种情况。

我将代码调整为不缓冲，只在收到时打印，一切正常。

Answer 1

在我看来，您的线程一次太多了。我不会从run_in_parallel 中穿出它，而只是用正确的参数调用run_server_client，因为它们会穿入其中。

Answer 2

我可以将旧代码更改为不使用os.fork()，但我也想知道为什么会导致此问题以及是否有可行的解决方案。

理解问题的关键是确切地知道fork() 做了什么。 CPython 文档声明“分叉子进程”。但这假定您了解 C 库调用 fork()。

glibc 的联机帮助页是这样说的：

fork() 通过复制调用进程来创建一个新进程。新进程（称为子进程）与调用进程（称为父进程）完全相同，但以下几点除外：...

这基本上就好像你拿了你的程序并复制了它的程序状态（堆、堆栈、指令指针等），但差别很小，让它独立于原始程序执行。当这个子进程自然退出时，它将使用exit()，这将触发multiprocessing模块注册的atexit()处理程序。

你能做些什么来避免它？

• 省略os.fork()：改用multiprocessing，就像您现在正在探索的那样
• 可能有效：import multiprocessing 在执行 fork() 后，仅在必要时在子级或父级中。
• 在子进程中使用_exit()（CPython 文档状态，“注意退出的标准方法是 sys.exit(n)。_exit() 通常只能在 fork() 之后的子进程中使用。”）

https://docs.python.org/2/library/os.html#os._exit