为什么 Python 多处理守护进程不打印到标准输出? [英] Why is a Python multiprocessing daemon process not printing to standard output?

问题描述

我一直在尝试多处理，但遇到了守护进程.

I have been experimenting with multiprocessing, and running into a mindblock with daemons.

我有一个守护进程和一个非守护进程，守护进程无限期地每隔一秒发出一次输出，而非守护进程在启动时立即打印输出，休眠 3 秒，然后再次打印并返回.

I have one daemon and one non-daemon process, the daemon emitting output every one second indefinitely, while the non-daemon prints output immediately upon start, sleeps for 3 seconds, then prints again and returns.

问题是，守护进程的预期输出根本没有出现.

The problem is, the expected output from the daemon process doesn't show up at all.

回顾过去关于守护进程的 SO 问题，常见问题似乎是在守护进程之前结束的其他进程，或者需要刷新以显示输出的标准输出.两者都已解决(我认为)，但我仍然只看到非守护进程的打印输出.

Reviewing past SO questions on daemons, the common issues appear to be either the other processes ending before the daemon, or the stdout requiring flushing to show output. Both have (I think) been addressed, however I continue to only see printed output from non-daemonic processes.

代码:

from multiprocessing import Process, current_process
import sys
import time

def worker():
    """
    Announce that the process has started, sleep 3 seconds
    then announce that the process is ending.
    """
    name = current_process().name
    print name, 'starting...'
    sys.stdout.flush()

    time.sleep(3)
    print name, 'ending...'
    sys.stdout.flush()

    return


def daemon():
    """
    Announce that the process has started, beep, then beep
    once every second
    """
    name = current_process().name
    print name, 'starting...'
    print 'beep...'
    sys.stdout.flush()

    while True:
        time.sleep(1)
        print 'beep...'
        sys.stdout.flush()


if __name__=='__main__':
    d = Process(target=daemon)
    d.daemon = True
    d.start()

    p = Process(target=worker)
    p.daemon = False
    p.start()

预期输出:

Process-1 starting... # Order here may vary
beep...
Process-2 starting...
beep...
beep...
Process-2 ending... #There may or may not be another beep here

实际生产出来的东西:

Process-2 starting...
Process-2 ending...

任何关于为什么会发生这种情况的建议将不胜感激.

Any advice on why this is happening would be truly appreciated.

推荐答案

通过放置开启日志，可以更清晰的了解事件的顺序

You can get a clearer picture of the order of events by turning on logging by placing

import multiprocessing as mp
logger = mp.log_to_stderr(logging.INFO)

在其他导入语句之后.然后你的程序会产生类似的东西:

after the other import statements. Then your program will yield something like:

[INFO/Process-1] child process calling self.run()
[INFO/MainProcess] process shutting down
Process-1 starting...
beep...
[INFO/Process-2] child process calling self.run()
[INFO/MainProcess] calling terminate() for daemon Process-1
Process-2 starting...
[INFO/MainProcess] calling join() for process Process-2
Process-2 ending...
[INFO/Process-2] process shutting down
[INFO/Process-2] process exiting with exitcode 0
[INFO/MainProcess] calling join() for process Process-1

因此，主进程首先开始关闭，然后终止进程-1，即守护进程.这就是为什么您在 Process-2 继续时看不到任何哔哔声.

Thus, the main starts shutting down first, then it terminates Process-1, the daemon process. That's why you do not see any more beeps while Process-2 continues.

这篇关于为什么 Python 多处理守护进程不打印到标准输出?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！