import os

import socket

import fcntl

def set_close_exec(fd):

    flags = fcntl.fcntl(fd, fcntl.F_GETFD)

    fcntl.fcntl(fd, fcntl.F_SETFD, flags | fcntl.FD_CLOEXEC)

a = '你好'

sk = socket.socket()

set_close_exec(sk.fileno())

sk.bind(('127.0.0.1', 8888))

sk.listen(1)

def start_child():

    id = os.fork()

    if id == 0:

        print('I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()))

        print(a)

        print('----------', sk.fileno())

        return

    else:

        print('I (%s) just created a child process (%s).' % (os.getpid(), id))

print('haha')

start_child()

print('done')

可以通过这段代码简单测验一下fork调用的特性

sockets = bind_sockets(8888)

tornado.process.fork_processes(0)

server = TCPServer()

server.add_sockets(sockets)

IOLoop.current().start()

def fork_processes(num_processes, max_restarts=100):

    # 第一个参数表示启动多少个子进程，第二个参数表示当子进程由于某些情况结束，父进程可以重新启动一个子进程的次数

    global _task_id

    assert _task_id is None

    # 默认生成的子进程的个数等于cpu个数

    if num_processes is None or num_processes <= 0:

        num_processes = cpu_count()

    # 不允许在未完成创建子进程之前启动ioloop

    if ioloop.IOLoop.initialized():

        raise RuntimeError("Cannot run in multiple processes: IOLoop instance "

                           "has already been initialized. You cannot call "

                           "IOLoop.instance() before calling start_processes()")

    gen_log.info("Starting %d processes", num_processes)

    children = {}

    def start_child(i):

        pid = os.fork()

        if pid == 0: # 表示子进程

            # child process

            _reseed_random()

            global _task_id

            _task_id = i

            return i  # 子进程会直接退出该函数(也就是start_child)的执行，并返回i的值

        else:

            # 父进程则会将子进程pid与子进程对应的i值进行映射，然后返回None

            children[pid] = i

            return None

    for i in range(num_processes):

        id = start_child(i)

        # 因为子进程继承了父进程的执行流，并且子进程不应fork子进程，而是应该由父进程进行对子进程的创建和管理等操作

        # 所以子进程的执行流需要跳出fork_processes这个函数

        if id is not None:

            return id

    num_restarts = 0

    # 只有父进程的执行流才能到达这里，父进程的执行流会一直处于该循环中，直到tornado服务主动关闭

    while children:

        try:

            # 等待任何一个子进程结束，返回一个tuple，包括子进程的进程ID和退出状态信息

            pid, status = os.wait()

        except OSError as e:

            # 当阻塞于某个慢系统调用的一个进程捕获某个信号且相应信号处理函数返回时，该系统调用可能返回一个EINTR错误

            if errno_from_exception(e) == errno.EINTR:

                continue

            raise

        if pid not in children:

            continue

        id = children.pop(pid)

        if os.WIFSIGNALED(status): # 如果进程由于信号而退出，则返回True，否则返回False

            gen_log.warning("child %d (pid %d) killed by signal %d, restarting",

                            id, pid, os.WTERMSIG(status))

        elif os.WEXITSTATUS(status) != 0: # 如果WIFEXITED(status)返回True，则返回一个整数，该整数是exit()调用的参数。否则返回值是未定义的

            gen_log.warning("child %d (pid %d) exited with status %d, restarting",

                            id, pid, os.WEXITSTATUS(status))

        else:

            gen_log.info("child %d (pid %d) exited normally", id, pid)

            continue

        num_restarts += 1

        if num_restarts > max_restarts:

            raise RuntimeError("Too many child restarts, giving up")

        # 新启动一个子进程

        new_id = start_child(id)

        # 保证子进程执行流离开fork_processes函数

        if new_id is not None:

            return new_id

    # 当所有的子进程都完全退出，这时候我们需要结束父进程

    # 如果我们仅仅是结束fork_processes函数的执行，那么父进程的执行流可能会启动ioloop

    sys.exit(0)

def add_sockets(self, sockets):

        if self.io_loop is None:

            self.io_loop = IOLoop.current()    # 获取IOLoop实例对象

        for sock in sockets:

            self._sockets[sock.fileno()] = sock

            add_accept_handler(sock, self._handle_connection, io_loop=self.io_loop)

def add_accept_handler(sock, callback, io_loop=None):

    if io_loop is None: # 获取IOLoop实例对象

        io_loop = IOLoop.current()

    def accept_handler(fd, events):

        # 我们处理回调时可能会有许多的连接等待建立; 为了防止其他任务的饥饿，我们必须限制我们一次接受的连接数。

        # 理想情况下，我们接受在处理回调过程中等待的连接数，但此可能会对负载产生不利影响。

        # 相反，我们使用listen backlog作为我们可以合理接受的连接数的。

        for i in xrange(_DEFAULT_BACKLOG): # _DEFAULT_BACKLOG默认为128

            try:

                connection, address = sock.accept()

            except socket.error as e:

                # _ERRNO_WOULDBLOCK 与EAGAIN相同，表示再尝试一下，很多情况下是因为资源不足，或者条件未达成

                # 当某个子进程与客户端建立了连接，其他子进程再次尝试与该客户端建立连接时就会产生该错误

                if errno_from_exception(e) in _ERRNO_WOULDBLOCK:

                    return

                # ECONNABORTED表示有一个连接，在他处于等待被服务端accept的时候主动关闭了。

                if errno_from_exception(e) == errno.ECONNABORTED:

                    continue

                raise

            callback(connection, address)

    io_loop.add_handler(sock, accept_handler, IOLoop.READ) # 为socket注册handler：当发生READ事件时运行accept_handler函数。

def start(self):

        try:

            while True:

                callbacks = self._callbacks

                self._callbacks = []

                due_timeouts = []

                # 将时间已到的定时任务放置到due_timeouts中，过程省略

                for callback in callbacks:          # 执行callback

                    self._run_callback(callback)

                for timeout in due_timeouts:        # 执行定时任务

                    if timeout.callback is not None:

                        self._run_callback(timeout.callback)

                callbacks = callback = due_timeouts = timeout = None    # 释放内存

                # 根据情况设置poll_timeout的值，过程省略

                if not self._running:    # 终止ioloop运行时，在执行完了callback后结束循环

                    breaktry:

                    event_pairs = self._impl.poll(poll_timeout)

                except Exception as e:

                    if errno_from_exception(e) == errno.EINTR:  # 系统调用被信号处理函数中断，进行下一次循环

                        continue

                    else:

                        raise

                self._events.update(event_pairs)

                while self._events:

                    fd, events = self._events.popitem()             # 获取一个fd以及对应事件

                    try:

                        fd_obj, handler_func = self._handlers[fd]   # 获取该fd对应的事件处理函数

                        handler_func(fd_obj, events)                # 运行该事件处理函数

                    except (OSError, IOError) as e:

                        if errno_from_exception(e) == errno.EPIPE:     # 当客户端关闭连接时会产生EPIPE错误

                            pass

                        # 其他异常处理已经省略

                fd_obj = handler_func = None       # 释放内存空间