如何在函数内初始化并行独立进程？

Question

抱歉，如果标题很奇怪。让我解释一下。

假设有handler.py：

import funcs
import requests

def initialize_calculate(data):
   check_data(data)
   funcs.calculate(data) # takes a lot of time like 30 minutes
   print('Calculation launched')
   requests.get('hostname', params={'func':'calculate', 'status':'launched'})

这里是funcs.py:

import requests

def calculate(data):
   result = make_calculations(data)
   requests.get('hostname',params={'func':'calculate', 'status':'finished', 'result':result})

所以我想要的是处理程序可以在任何地方初始化另一个函数，但不会等到它结束，因为我想通知客户端进程已经启动，当它完成时，这个进程本身会发送结果当它完成时。

如何使用 initialize_calculate 的函数计算启动独立进程？

我想知道如果没有非本地库或框架是否有可能。

Answer 1

如果您不想使用像 daemonocle 这样的第 3 方库来实现“行为良好”Unix-Daemon，您可以 使用subprocess.Popen() 创建一个独立的进程。另一种选择是修改multiprocessing.Process 以防止在父级退出时子级自动加入。

---

subprocess.Popen()

使用subprocess.Popen()，您可以通过从终端手动指定命令和参数来启动新进程。这意味着您需要将funcs.py 或其他文件设为顶级脚本，该脚本从标准输入解析字符串参数，然后使用这些参数调用funcs.calculate()。

我将您的示例归结为本质，因此我们不必阅读太多代码。

funcs.py

#!/usr/bin/env python3
# UNIX: enable executable from terminal with: chmod +x filename
import os
import sys
import time

import psutil  # 3rd party for demo


def print_msg(msg):
    print(f"[{time.ctime()}, pid: {os.getpid()}] --- {msg}")


def calculate(data, *args):
    print_msg(f"parent pid: {psutil.Process().parent().pid}, start calculate()")
    for _ in range(int(500e6)):
        pass
    print_msg(f"parent pid: {psutil.Process().parent().pid}, end calculate()")


if __name__ == '__main__':

    if len(sys.argv) > 1:
        calculate(*sys.argv[1:])

subp_main.py

#!/usr/bin/env python3
# UNIX: enable executable from terminal with: chmod +x filename
if __name__ == '__main__':

    import time
    import logging
    import subprocess
    import multiprocessing as mp

    import funcs

    mp.log_to_stderr(logging.DEBUG)

    filename = funcs.__file__
    data = ("data", 42)

    # in case filename is an executable you don't need "python" before `filename`:
    subprocess.Popen(args=["python", filename, *[str(arg) for arg in data]])
    time.sleep(1)  # keep parent alive a bit longer for demo
    funcs.print_msg(f"exiting")

对于测试很重要，从终端运行，例如不是 PyCharm-Run，因为它不会显示孩子打印的内容。在下面的最后一行中，您可以看到子进程的 parent-id 更改为 1，因为在父进程退出后，子进程被 systemd (Ubuntu) 收养。

$> ./subp_main.py
[Fri Oct 23 20:14:44 2020, pid: 28650] --- parent pid: 28649, start calculate()
[Fri Oct 23 20:14:45 2020, pid: 28649] --- exiting
[INFO/MainProcess] process shutting down
[DEBUG/MainProcess] running all "atexit" finalizers with priority >= 0
[DEBUG/MainProcess] running the remaining "atexit" finalizers
$> [Fri Oct 23 20:14:54 2020, pid: 28650] --- parent pid: 1, end calculate()

---

class OrphanProcess(multiprocessing.Process)

如果您搜索更方便的东西，那么您不能按原样使用高级multiprocessing.Process，因为它不会让父进程退出在子进程之前，因为您要求。当父进程关闭时，常规子进程要么加入（等待）要么终止（如果您为Process 设置了daemon-标志）。这仍然发生在 Python 中。请注意，daemon-flag 不会使进程成为 Unix-守护进程。命名是confusion 的常见来源。

我对@9​​87654346@ 进行了子类化，以关闭自动加入功能，并花一些时间查看源代码并观察zombies 是否会成为问题。因为修改关闭了父进程中的自动加入，我建议在 Unix 上使用“forkserver”作为新进程的启动方法（如果父进程已经是多线程的，这总是一个好主意）以防止僵尸子进程停留太久父级仍在运行。当父进程终止时，它的子僵尸最终会通过 systemd/init 获得reaped。运行 multiprocessing.log_to_stderr() 显示一切都干净利落地关闭，所以到目前为止似乎没有任何问题。

认为这种方法是实验性的，但它可能比使用原始 os.fork() 重新发明一部分广泛的 multiprocessing 机制要安全得多，只是为了添加这一功能。对于子级的错误处理，编写一个 try-except 块并记录到文件中。

orphan.py

import multiprocessing.util
import multiprocessing.process as mpp
import multiprocessing as mp

__all__ = ['OrphanProcess']


class OrphanProcess(mp.Process):
    """Process which won't be joined by parent on parent shutdown."""
    def start(self):
        super().start()
        mpp._children.discard(self)

    def __del__(self):
        # Finalizer won't `.join()` the child because we discarded it,
        # so here last chance to reap a possible zombie from within Python.
        # Otherwise systemd/init will reap eventually.
        self.join(0)

orph_main.py

#!/usr/bin/env python3
# UNIX: enable executable from terminal with: chmod +x filename
if __name__ == '__main__':

    import time
    import logging
    import multiprocessing as mp
    from orphan import OrphanProcess
    from funcs import print_msg, calculate

    mp.set_start_method("forkserver")
    mp.log_to_stderr(logging.DEBUG)

    p = OrphanProcess(target=calculate, args=("data", 42))
    p.start()
    time.sleep(1)
    print_msg(f"exiting")

再次从终端测试以将子打印到标准输出。在第二个提示符打印完所有内容后，当 shell 似乎挂起时，按 Enter 键以获取新提示符。 parent-id 在这里保持不变，因为从操作系统的角度来看，父进程是 forkserver 进程，而不是 orph_main.py 的初始主进程。

$> ./orph_main.py
[INFO/MainProcess] created temp directory /tmp/pymp-bd75vnol
[INFO/OrphanProcess-1] child process calling self.run()
[Fri Oct 23 21:18:29 2020, pid: 30998] --- parent pid: 30997, start calculate()
[Fri Oct 23 21:18:30 2020, pid: 30995] --- exiting
[INFO/MainProcess] process shutting down
[DEBUG/MainProcess] running all "atexit" finalizers with priority >= 0
[DEBUG/MainProcess] running the remaining "atexit" finalizers
$> [Fri Oct 23 21:18:38 2020, pid: 30998] --- parent pid: 30997, end calculate()
[INFO/OrphanProcess-1] process shutting down
[DEBUG/OrphanProcess-1] running all "atexit" finalizers with priority >= 0
[DEBUG/OrphanProcess-1] running the remaining "atexit" finalizers
[INFO/OrphanProcess-1] process exiting with exitcode 0

Answer 2

您可以使用multiprocessing 模块中的Process class 来执行此操作。

这是一个例子：

from multiprocessing import Process
import requests

def calculate(data):
    result = make_calculations(data)
    requests.get('hostname',params={'func':'calculate', 'status':'finished', 'result':result})

def initialize_calculate(data):
    check_data(data)
    p = Process(target=calculate, args=(data,))
    p.start()
    print('Calculation launched')
    requests.get('hostname', params={'func':'calculate', 'status':'launched'})