【Python】为什么下面这段代码不会产生大量的僵尸进程？？

代码如下，我觉得补上几张图吧。真的出现了这个奇怪的问题。
照理说应该会产生大量的僵尸进程的丫。可是我查看了进程却只有一个当下的僵尸进程。为什么呢？
系统是Ubuntu16.04，python版本是3.5

代码一

import multiprocessing as mp
import os
import time
def pro():
print ("os.pid is ", os.getpid())
if __name__ == '__main__':
print ("parent ", os.getpid())
while True:
p = mp.Process(target = pro)
p.start()
time.sleep(1)

代码一图示：
【Python】为什么下面这段代码不会产生大量的僵尸进程？？

代码二

如果换成用C来编写一段类似的代码，却会产生大量的子进程。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
int main()
{
pid_t pid;
while (1){
pid = fork();
if (pid < 0){
puts("fock error");
exit(1);
}
else if(pid == 0){
printf("I am a Child Process, pid is %d.\n", getpid());
sleep(1);
exit(1);
}
else
sleep(3);
}
return 0;
}

代码二图示：
【Python】为什么下面这段代码不会产生大量的僵尸进程？？

代码三

用python继续写一段没有循环的代码也一样会产生一个僵尸进程

from multiprocessing import Process
import os
import time
def run():
print ("pid is ", os.getpid())
p = Process(target = run)
p.start()
time.sleep(100)

代码三图示：
【Python】为什么下面这段代码不会产生大量的僵尸进程？？

为什么会这样丫???僵尸进程的产生原因我应该没理解错的吧。就是父进程在子进程死后没有去理会子进程导致的问题。但是代码一和代码二三好像没有什么区别丫，可是代码一却没有产生一堆的僵尸进程，真的不是很理解了。

回答

谢邀，三段代码。第一段比较好理解吧。新建的进程只有一个print，执行完就会结束了，python会自动回收这个子进程，没有僵尸进程的，你看到的应该是主进程吧。

第二段C代码，死循环中有一个 fork 。然后子进程调用 exit 后成为了一个僵尸进程。父进程一直不会关闭。
所以就不断产生僵尸进程了啊，正确的做法是在父进程中回收子进程：

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
int main()
{
    pid_t pid;
    int status;
    while (1){
        pid = fork();
        if (pid < 0){
            puts("fock error");
            exit(1);
        }
        else if(pid == 0){
            printf("I am a Child Process, pid is %d.\n", getpid());
            sleep(1);
            exit(1);
        }
        else{
            wait(&status); // 回收子进程
            sleep(3);
        }
    }
    return 0;
}

第三段，额，同第一段，你看到的应该就是主线程了。

---- 分割线 ------
根据题主的截图，我执行了一下，还真是会有一个僵尸进程，惭愧，居然和印象中的不一样。但是这个僵尸进程只有一个，不会像C语言那段代码一样是不断产生的。于是我就去看看python是如何处理子进程的。mutilprossing.Process 继承自 BaseProcess 文件在 Lib/mutilprossing/process.py 中，我们看看它的start方法:

_children = set()
class BaseProcess(object):
    def start(self):
        self._check_closed()
        assert self._popen is None, 'cannot start a process twice'
        assert self._parent_pid == os.getpid(), \
               'can only start a process object created by current process'
        assert not _current_process._config.get('daemon'), \
               'daemonic processes are not allowed to have children'
        _cleanup()
        self._popen = self._Popen(self)
        self._sentinel = self._popen.sentinel
        # Avoid a refcycle if the target function holds an indirect
        # reference to the process object (see bpo-30775)
        del self._target, self._args, self._kwargs
        _children.add(self)

_children 是一个全局的集合变量，保存着所有 BaseProcess 实例，start 函数末尾处 _children.add(self) 将进程对象放入。又注意到 _cleanup() 函数：

def _cleanup():
    # check for processes which have finished
    for p in list(_children):
        if p._popen.poll() is not None:
            _children.discard(p)

这下就清楚了，python在子进程start中将进程放入集合，子进程可能长时间运行，因此这个集合上的进程会有很多状态，而为了防止过多僵尸进程导致资源占用，python会在下一个子进程 start 时清理僵尸进程。所以，最后一个子进程在自身程序运行完毕后就变成僵尸进程，它在等待下一个子进程start时被清理。所以 ps 上总有一个僵尸进程，但这个僵尸进程的进程id一直在变化。

python确实做到自动清理了，是我自己混淆了，看来以后要多多看看源码才行了。

关于C语言的僵尸进程上面已经回答了。如果子进程先于父进程退出， 同时父进程又没有调用 wait/waitpid ，则该子进程将成为僵尸进程。

因为你的进程执行完了那一行 print 之后就结束了，如果你的 pro 方法里是一个死循环的话应该就会有大量僵尸进程了。

首先是，主进程退出，子进程或子线程都会退出，这个没什么问题。
再就是下面这段代码，应该是不会产生僵死进程的，因为子进程run方法运行的很快，而主进程sleep 100s，所以不会产生主进程先退出（不知道你是怎么看到有僵死进程的）

from multiprocessing import Process
import os
import time
def run():
    print ("pid is ", os.getpid())
p = Process(target = run)
p.start()
time.sleep(100)

第一段程序，你在pro函数里增加个sleep，就能看到有多个子进程了。

def pro():
    print ("os.pid is ", os.getpid())
    time.sleep(3)

http://blog.sina.com.cn/s/blo...

以上是 【Python】为什么下面这段代码不会产生大量的僵尸进程？？ 的全部内容， 来源链接： utcz.com/a/78643.html

回到顶部