戏说守护、僵尸、孤儿进程

戏说守护、僵尸、孤儿进程

auxtenauxten

首先说简单的结论

  1. 没有父进程的进程就是孤儿进程,孤儿进程会被init领养,成为一个准守护进程。

  2. 如果进程他爹活着,但是不给子进程收尸(wait、waitpid),子进程就会变成僵尸。

守护进程(Daemon)是在一类脱离终端在后台执行的程序, 通常以 d 结尾, 随系统启动, 其父进程 (ppid) 通常是 init 进程

以下是Wikipedia中关于Daemon的定义:

In multitasking computer operating systems, a daemon (/ˈdiːmən/ or /ˈdeɪmən/) is a computer program that runs as a background process, rather than being under the direct control of an interactive user. Traditionally daemon names end with the letter d: for example, syslogd is the daemon that implements the system logging facility and sshd is a daemon that services incoming SSH connections.

一般要让当前程序以守护进程形式运行, 在命令后加 & 并重定向输出即可:

$ nohup some_program > /dev/null 2>&1 &

这是直接运行程序的方式, 如果是用具体语言代码的形式来实现呢, 总的来说守护进程应该有以下几个特征:

  • 后台运行

    也就是不占用console的前面,也就是bash里运行程序后面加个&

  • 成为process group leader

    Process Group Leader就是父进程是init的那个进程。

  • 成为session leader

    一个ssh登录会启动一个bash,bash会fork出很多子进程,这些进程轮流接手tty输出。这都是属于一个session。 session leader就是这一堆进程的父进程。

  • fork一次或者两次

    fork 两次是出于被当成库调用的考虑。

  • chdir到/

    防止占用别的路径的working dir的fd,导致一些block不能unmount

  • umask

    需要重置umask,防止后续子进程继承非默认umask造成奇怪的行为。

  • 处理标准输入输出,错误输出(0,1,2)

    重定向stdout、stderr、stdin,防止tty中断后的broken pipe信号。

  • 日志

    输出重定向后,需要有办法反映内部情况。


  • 信号处理

    最后最好对将一些终端相关的信号处理忽略一下,防止受到相关信号导致的进程退出。例如:SIGHUP、SIGTTIN、SIGTTOU。这是很多没有经验的菜鸟容易忽略的点。一般nohup命令会帮我们处理。

用下面的代码就可以实现一个非常规范的守护进程(代码注释很详细但有点长):

#!/usr/bin/env python

import sys, os, time, atexit
from signal import SIGTERM

class Daemon:
  """
  A generic daemon class.
   
  Usage: subclass the Daemon class and override the run() method
  """
  def __init__(self, pidfile='nbMon.pid', stdin='/dev/null', stdout='nbMon.log', stderr='nbMon.log'):
    self.stdin = stdin
    self.stdout = stdout
    self.stderr = stderr
    self.pidfile = pidfile
   
  def daemonize(self):
    """
    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)
    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("/")
    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(self.stdin, 'r')
    so = file(self.stdout, 'a+')
    se = file(self.stderr, 'a+', 0)
    os.dup2(si.fileno(), sys.stdin.fileno())
    os.dup2(so.fileno(), sys.stdout.fileno())
    os.dup2(se.fileno(), sys.stderr.fileno())
   
    # write pidfile
    atexit.register(self.delpid)
    pid = str(os.getpid())
    file(self.pidfile,'w+').write("%s\n" % pid)
   
  def delpid(self):
    os.remove(self.pidfile)

  def start(self):
    """
    Start the daemon
    """
    # Check for a pidfile to see if the daemon already runs
    try:
      pf = file(self.pidfile,'r')
      pid = int(pf.read().strip())
      pf.close()
    except IOError:
      pid = None
   
    if pid:
      message = "pidfile %s already exist. Daemon already running?\n"
      sys.stderr.write(message % self.pidfile)
      sys.exit(1)
     
    # Start the daemon
    self.daemonize()
    self.run()

  def stop(self):
    """
    Stop the daemon
    """
    # Get the pid from the pidfile
    try:
      pf = file(self.pidfile,'r')
      pid = int(pf.read().strip())
      pf.close()
    except IOError:
      pid = None
   
    if not pid:
      message = "pidfile %s does not exist. Daemon not running?\n"
      sys.stderr.write(message % self.pidfile)
      return # not an error in a restart

    # Try killing the daemon process     
    try:
      while 1:
        os.kill(pid, SIGTERM)
        time.sleep(0.1)
    except OSError, err:
      err = str(err)
      if err.find("No such process") > 0:
        if os.path.exists(self.pidfile):
          os.remove(self.pidfile)
      else:
        print str(err)
        sys.exit(1)

  def restart(self):
    """
    Restart the daemon
    """
    self.stop()
    self.start()

  def run(self):
    """
    You should override this method when you subclass Daemon. It will be called after the process has been
    daemonized by start() or restart().
    """

可以看一个示例:

#!/usr/bin/env python
# coding=utf-8

from daemon import Daemon
import socket
import time

html = """HTTP/1.1 200 OK\r\nContent-Type: image/jpeg\r\nConnection: close\r\nContent-Length: """
html404 = """HTTP/1.1 404 Not Found\r\nContent-Type: text/html\r\nContent-Length: 13\r\n\r\n<h1>404 </h1>"""

class agentD(Daemon):
  def run(self):
    listen_fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
    listen_fd.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    listen_fd.bind(("0.0.0.0", 9000))
    listen_fd.listen(10)
    while True:
      conn, addr = listen_fd.accept()
      print "coming", conn, addr
      read_data = conn.recv(10000)
      #print read_data
      try:
        pic_name = read_data.split(" ")[1][1:]
        print pic_name
        with file(pic_name) as f:
          pic_content = f.read()
          length = len(pic_content)
          html_resp = html
          html_resp += "%d\r\n\r\n" % (length)
          print html_resp
          html_resp += pic_content
      except:
        print "404 occur"
        html_resp = html404
      
      while len(html_resp) > 0: 
        sent_cnt = conn.send(html_resp)
        print "sent:", sent_cnt
        html_resp = html_resp[sent_cnt:]
      conn.close()

if __name__ == "__main__":
  agentd = agentD(pidfile="agentd.pid", stdout="agentd.log", stderr="agentd.log")
  agentd.run()

实现了一个非常蹩脚的HTTP Server :-P

上面守护进程的生成步骤中涉及到了孤儿进程:任何孤儿进程产生时都会立即为系统进程init自动接收为子进程,这一过程也被称为“收养”。但由于创建该进程的进程已不存在,所以仍应称之为“孤儿进程(Orphan Process)”。

与之相关的一个概念就是 僵尸进程(Zombie Process)了。当子进程退出时, 父进程需要wait/waitpid系统调用来读取子进程的exit status, 然后子进程被系统回收。如果父进程没有wait的话, 子进程将变成一个"僵尸进程", 内核会释放这个子进程所有的资源,包括打开的文件占用的内存等。但在进程表中仍然有一个PCB, 记录进程号和退出状态等信息, 并导致进程号一直被占用, 而系统能使用的进程号数量是有限的(可以用ulimit查看相关限制), 如果产生大量僵尸进程的话, 将因为没有可用的进程号而导致系统不能产生新的进程。

因此很多自带重启功能的服务实现就是用wait/waitpid实现的。waitpid()会暂时停止目前进程的执行,直到有信号来到或子进程结束。比如tornado中fork多进程就是这样, 监控子进程的运行状态, 当其意外退出时自动重启子进程。


最后做个小广告,欢迎大家关注公共号,高品质运维开发,我们每周五晚上还会做线上公开课,加QQ群 368573673 报名即可,都是关于Linux、运维、Python和前端的相关内容


运维开发交流QQ群: 238757010

欢迎大家关注公共号,高品质运维开发

关于Reboot:

专注于互联网运维开发分享、交流,让更多的运维工程师更加专注于自动化,为国内公有云开发、监控、运维贡献自己的力量。这里聚集着国内一线互联网工程师,乐于分享与交流 。发现文章不错的话请关注我们。


Reboot于每周五开展免费技术沙龙分享

时间:本周五(5月27日),21:00开始(明晚)

方式:网络直播

内容:

主题:浅析Ceph

主讲人:前360分布式攻城狮

内容:

解开Ceph神秘的面纱

Ceph工作原理及流程
Ceph 日常维护及常用操作

参与请加分享群:368573673

「真诚赞赏,手留余香」
还没有人赞赏,快来当第一个赞赏的人吧!
文章被以下专栏收录
4 条评论
推荐阅读