在Python中产生无限守护进程

Question

我试图构建一个启动其他完全独立进程的Python守护进程。

总体思路是针对给定的shell命令，每隔几秒轮询一次，并确保该命令的实例正在运行。我们保留一个pidfiles的目录，当我们调查时，我们删除那些pid不再运行的pidfiles并启动（并为其制作pidfiles），但是我们需要去许多进程，其中包括k。

子进程也需要完全独立，这样如果父进程死了，子进程就不会被杀死。从我读过的书中看来，subprocess模块似乎没有办法做到这一点。为此，我使用的片断这里提到：

http://code.activestate.com/recipes/66012-fork-a-daemon-process-on-unix/

我做了几个必要的修改（你会看到在连接段注释掉行）：

1. 原始父进程无法退出，因为我们需要启动程序守护进程无限期地持续存在。
2. 子进程需要以与父进程相同的cwd开始。

这里是我的产卵fn和测试：

import os 
import sys 
import subprocess 
import time 

def spawn(cmd, child_cwd): 
    """ 
    do the UNIX double-fork magic, see Stevens' "Advanced 
    Programming in the UNIX Environment" for details (ISBN 0201563177) 
    http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16 
    """ 
    try: 
     pid = os.fork() 
     if pid > 0: 
      # exit first parent 
      #sys.exit(0) # parent daemon needs to stay alive to launch more in the future 
      return 
    except OSError, e: 
     sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror)) 
     sys.exit(1) 

    # decouple from parent environment 
    #os.chdir("/") # we want the children processes to 
    os.setsid() 
    os.umask(0) 

    # do second fork 
    try: 
     pid = os.fork() 
     if pid > 0: 
      # exit from second parent 
      sys.exit(0) 
    except OSError, e: 
     sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror)) 
     sys.exit(1) 

    # redirect standard file descriptors 
    sys.stdout.flush() 
    sys.stderr.flush() 
    si = file('/dev/null', 'r') 
    so = file('/dev/null', 'a+') 
    se = file('/dev/null', 'a+', 0) 
    os.dup2(si.fileno(), sys.stdin.fileno()) 
    os.dup2(so.fileno(), sys.stdout.fileno()) 
    os.dup2(se.fileno(), sys.stderr.fileno()) 

    pid = subprocess.Popen(cmd, cwd=child_cwd, shell=True).pid 

    # write pidfile  
    with open('pids/%s.pid' % pid, 'w') as f: f.write(str(pid)) 
    sys.exit(1) 

def mkdir_if_none(path): 
    if not os.access(path, os.R_OK): 
     os.mkdir(path) 

if __name__ == '__main__': 
    try: 
     cmd = sys.argv[1] 
     num = int(sys.argv[2]) 
    except: 
     print 'Usage: %s <cmd> <num procs>' % __file__ 
     sys.exit(1) 
    mkdir_if_none('pids') 
    mkdir_if_none('test_cwd') 

    for i in xrange(num): 
     print 'spawning %d...'%i 
     spawn(cmd, 'test_cwd') 
     time.sleep(0.01) # give the system some breathing room 

在这种情况下，事情似乎很好地工作，而当父母被杀害的子进程仍然持续。但是，我仍然遇到了原始父级的产生限制。后〜650鱼卵（不同时，孩子们已经完成），父进程扼流圈与错误：

spawning 650... 
fork #2 failed: 35 (Resource temporarily unavailable) 

有什么办法重写我的产卵函数，这样我可以无限期地产卵这些独立的子进程？谢谢！

Answer 1

感谢your list of processes我愿意说，这是因为你已经打了一些基本限制之一：

• RLIMIT nproc的给定用户的最大进程数允许执行 - 请参阅setrlimit(2),bash(1)ulimit内置和/etc/security/limits.conf以了解有关每个用户进程限制的详细信息。
• rlimit nofile给定进程被允许一次打开的文件描述符的最大数量。 （每一个新的进程可能会在父三个新的管道，对孩子的stdin，stdout，并stderr描述。）
• 全系统的最大进程数;见/proc/sys/kernel/pid_max。
• 系统范围内打开文件的最大数量;见/proc/sys/fs/file-max。

因为你没有收获你死去的孩子，许多这些资源的开放时间比他们应该的时间更长。你的第二个孩子正在妥善处理init(8) - 他们的父母已经死亡，所以他们重新回到init(8)，init(8)将在他们死亡后（wait(2)）清理。

但是，您的程序负责清理后的第一批儿童。 C程序通常会安装一个signal(7)处理程序SIGCHLD，该处理程序调用wait(2)或waitpid(2)来获取子级的退出状态，从而从内核内存中删除它的条目。

但是脚本中的信号处理有点烦人。如果您可以明确地将SIGCHLD信号处理设置为SIG_IGN，则内核将知道您对退出状态不感兴趣，并且将为您收获子女。

尝试增加：

import signal 
signal.signal(signal.SIGCHLD, signal.SIG_IGN) 

近程序的顶部。

请注意，我不知道这对Subprocess有什么作用。它可能不会很高兴。如果是这种情况，那么您需要install a signal handler为您拨打wait(2)。

Answer 2

我稍微修改了你的代码，并且能够在没有任何问题的情况下运行5000个进程。所以我同意@sarnold，你有一些根本的限制。我的修改是：

proc = subprocess.Popen(cmd, cwd=child_cwd, shell=True, close_fds=True)  
pid = proc.pid 

# write pidfile  
with open('pids/%s.pid' % pid, 'w') as f: f.write(str(pid)) 
proc.wait() 
sys.exit(1)