python 与父母一起杀死孩子
声明：本页面是StackOverFlow热门问题的中英对照翻译，遵循CC BY-SA 4.0协议，如果您需要使用它，必须同样遵循CC BY-SA许可，注明原文地址和作者信息，同时你必须将它归于原作者（不是我）：StackOverFlow
原文地址: http://stackoverflow.com/questions/1884941/
Warning: these are provided under cc-by-sa 4.0 license. You are free to use/share it, But you must attribute it to the original authors (not me):
StackOverFlow
Killing the children with the parent
提问by Thomas Ahle
I have a program spawning and communicating with CPU heavy, unstable processes, not created by me. If my app crashes or is killed by SIGKILL, I want the subprocesses to get killed as well, so the user don′t have to track them down and kill them manually.
我有一个程序生成并与 CPU 繁重、不稳定的进程通信，这不是我创建的。如果我的应用程序崩溃或被 杀死SIGKILL，我希望子进程也被杀死，这样用户就不必跟踪它们并手动杀死它们。
I know this topic has been covered before, but I have tried all methods described, and none of them seem to live up to survive the test.
我知道之前已经讨论过这个主题，但我已经尝试了所有描述的方法，但似乎没有一种方法能够经受住考验。
I know it must be possible, since terminals do it all the time. If I run something in a terminal, and kill the terminal, the stuff always dies.
我知道这一定是可能的，因为终端一直在做。如果我在终端中运行某些东西并杀死终端，则这些东西总是会消失。
I have tried atexit, double fork and ptys. atexitdoesn't work for sigkill; double fork doesn't work at all; and ptysI have found no way to work with using python.
我试过atexit，双叉和ptys. atexit不适用于sigkill; 双叉根本不起作用；和ptys我没有发现任何方式与使用python的工作。
Today, I found out about prctl(PR_SET_PDEATHSIG, SIGKILL), which should be a way for child processes to order a kill on themselves, when their parent dies.
I tried to use it with popen, but it seams to have no effect at all:
今天，我发现了关于prctl(PR_SET_PDEATHSIG, SIGKILL)，这应该是子进程在其父进程死亡时下令杀死自己的一种方式。我尝试将它与 一起使用popen，但它接缝根本没有任何效果：
import ctypes, subprocess
libc = ctypes.CDLL('/lib/libc.so.6')
PR_SET_PDEATHSIG = 1; TERM = 15
implant_bomb = lambda: libc.prctl(PR_SET_PDEATHSIG, TERM)
subprocess.Popen(['gnuchess'], preexec_fn=implant_bomb)
In the above, the child is created and the parent exits. Now you would expect gnuchessto receive a SIGKILLand die, but it doesn't. I can still find it in my process manager using 100% CPU.
在上面，孩子被创建，父母退出。现在您希望gnuchess收到 aSIGKILL并死亡，但事实并非如此。我仍然可以在使用 100% CPU 的进程管理器中找到它。
Can anybody tell me if there is something wrong with my use of prctl?,
or do you know how terminals manage to kill their children?
任何人都可以告诉我我使用prctl?是否有问题，或者您知道终端如何设法杀死他们的孩子吗？
采纳答案by Alex Martelli
prctl's PR_SET_DEATHSIGcan only be set for this very process that's calling prctl-- not for any other process, including this specific process's children. The way the man page I'm pointing to expresses this is "This value is cleared upon a fork()" -- fork, of course, is the way other processes are spawned (in Linux and any other Unix-y OS).
使用prctl的PR_SET_DEATHSIG只能被设置为了这个过程，在呼叫使用prctl-没有任何其他进程，包括此特定进程的孩子。我指向的手册页表达的方式是“这个值在 fork() 上被清除”——fork当然，是其他进程的产生方式（在 Linux 和任何其他 Unix-y 操作系统中）。
If you have no control over the code you want to run in subprocesses (as would be the case, essentially, for your gnuchessexample), I suggest you first spawn a separate small "monitor" process with the role of keeping track of all of its siblings (your parent process can let the monitor know about those siblings' pids as it spawns them) and sending them killer signals when the common parent dies (the monitor needs to poll for that, waking up every N seconds for some N of your choice to check if the parent's still alive; use selectto wait for more info from the parent with a timeout of N seconds, within a loop).
如果您无法控制要在子gnuchess进程中运行的代码（对于您的示例，本质上就是这种情况），我建议您首先生成一个单独的小型“监视器”进程，其作用是跟踪其所有兄弟姐妹（您的父进程可以让监视器在生成这些兄弟姐妹时知道这些兄弟姐妹的 pid）并在公共父进程死亡时向它们发送杀手信号（监视器需要为此进行轮询，每 N 秒唤醒一次您选择的某些 N检查父母是否还活着；select用于在循环内等待来自父母的更多信息，超时为 N 秒）。
Not trivial, but then such system tasks often aren't. Terminals do it differently (via the concept of a "controlling terminal" for a process group) but of course it's trivial for any child to block THAT off (double forks, nohup, and so on).
并非微不足道，但此类系统任务通常并非如此。终端以不同的方式执行此操作（通过进程组的“控制终端”的概念），但当然，任何子进程阻止它（双叉，nohup等等）都是微不足道的。
回答by coolbho3k
I know it's been years, but I found a simple (slightly hacky) solution to this problem. From your parent process, wrapping all your calls around a very simple C program that calls prctl() and then exec() solves this problem on Linux. I call it "yeshup":
我知道已经很多年了，但我找到了一个简单（有点老套）的解决方案来解决这个问题。在您的父进程中，将所有调用包装在一个非常简单的 C 程序中，该程序调用 prctl() 然后 exec() 解决了 Linux 上的这个问题。我称之为“是的”：
#include <linux/prctl.h>
#include <signal.h>
#include <unistd.h>
int main(int argc, char **argv) {
if(argc < 2)
return 1;
prctl(PR_SET_PDEATHSIG, SIGHUP, 0, 0, 0);
return execvp(argv[1], &argv[1]);
}
When spawning your child processes from Python (or any other language), you can run "yeshup gnuchess [argments]." You'll find that, when the parent process is killed, all your child processes (should) be given SIGHUP nicely.
从 Python（或任何其他语言）生成子进程时，您可以运行“yeshup gnuchess [argments]”。你会发现，当父进程被杀死时，你所有的子进程（应该）得到很好的 SIGHUP。
This works because Linux will honor the call to prctl (not clear it) even after execvp is called (which effectively "transforms" the yeshup process into a gnuchess process, or whatever command you specify there), unlike fork().
这是有效的，因为即使在调用 execvp 之后，Linux 也会尊重对 prctl 的调用（不清除它）（这有效地将 yeshup 进程“转换”为 gnuchess 进程，或您在那里指定的任何命令），这与 fork() 不同。
回答by Paul Molodowitch
Actually I found that your original approach worked just fine for me - here's the exact example code I tested with which worked:
实际上，我发现您的原始方法对我来说效果很好 - 这是我测试过的确切示例代码：
echoer.py
回声器.py
#!/bin/env python
import time
import sys
i = 0
try:
while True:
i += 1
print i
time.sleep(1)
except KeyboardInterrupt:
print "\nechoer caught KeyboardInterrupt"
exit(0)
parentProc.py
父进程
#!/bin/env python
import ctypes
import subprocess
import time
libc = ctypes.CDLL('/lib64/libc.so.6')
PR_SET_PDEATHSIG = 1
SIGINT = 2
SIGTERM = 15
def set_death_signal(signal):
libc.prctl(PR_SET_PDEATHSIG, signal)
def set_death_signal_int():
set_death_signal(SIGINT)
def set_death_signal_term():
set_death_signal(SIGTERM)
#subprocess.Popen(['./echoer.py'], preexec_fn=set_death_signal_term)
subprocess.Popen(['./echoer.py'], preexec_fn=set_death_signal_int)
time.sleep(1.5)
print "parentProc exiting..."
回答by Mohamed Hamzaoui
回答by Edward Loper
I'm wondering if the PR_SET_PDEATHSIGflag is getting cleared, even though you set it after you fork(and before exec), so it seems from the docs like it shouldn'tget cleared.
我想知道PR_SET_PDEATHSIG标志是否被清除，即使你在你之后fork（和之前exec）设置了它，所以从文档看来它不应该被清除。
In order to test that theory, you could try the following: use the same code to run a subprocess that's written in C and basically just calls prctl(PR_GET_PDEATHSIG, &result)and prints the result.
为了测试该理论，您可以尝试以下操作：使用相同的代码运行一个用 C 编写的子进程，基本上只是调用prctl(PR_GET_PDEATHSIG, &result)和打印结果。
Another thing you might try: adding explicit zeros for arg3, arg4, and arg5 when you call prctl. I.e.:
您可能会尝试的另一件事是：在调用prctl. IE：
>>> implant_bomb = lambda: libc.prctl(PR_SET_PDEATHSIG, TERM, 0, 0, 0)
回答by BillMan
I thought the double fork was to detach from a controlling terminal. I'm not sure how you are trying to use it.
我认为双叉是从控制终端上分离的。我不确定你是如何尝试使用它的。
It's a hack, but you could always call 'ps' and search for the process name your trying to kill.
这是一个黑客，但你总是可以调用 'ps' 并搜索你试图杀死的进程名称。
回答by pestilence669
I've seen very nasty ways of "clean-up" using things like ps xuawww | grep myApp | awk '{ print $1}' | xargs -n1 kill -9
我见过非常讨厌的“清理”方法，比如 ps xuawww | grep myApp | awk '{ print $1}' | xargs -n1 kill -9
The client process, if popened, can catch SIG_PIPE and die. There are many ways to go about this, but it really depends on a lot of factors. If you throw some ping code (ping to parent) in the child, you can ensure that a SIG_PIPE is issued on death. If it catches it, which it should, it'll terminate. You'd need bidirectional communication for this to work correctly... or to always block against the client as the originator of communication. If you don't want to modify the child, ignore this.
客户端进程，如果弹出，可以捕获 SIG_PIPE 并死亡。有很多方法可以解决这个问题，但这实际上取决于很多因素。如果在子进程中抛出一些 ping 代码（ping 到父进程），则可以确保在死亡时发出 SIG_PIPE。如果它捕获它，它应该捕获它，它将终止。您需要双向通信才能正常工作……或者始终阻止作为通信发起者的客户端。如果您不想修改子项，请忽略此项。
Assuming that you don't expect the actual Python interpreter to segfault, you could add each PID to a sequence, and then kill on exit. This should be safe for exiting and even uncaught exceptions. Python has facilities to perform exit code... for clean-up.
假设您不希望实际的 Python 解释器出现段错误，您可以将每个 PID 添加到一个序列中，然后在退出时终止。这对于退出甚至未捕获的异常应该是安全的。Python 具有执行退出代码的功能......以进行清理。
Here's some safer nasty: Append each child PID to a file, including your master process (separate file). Use file locking. Build a watchdog daemon that looks at the flock() state of your master pid. If it's not locked, kill every PID in your child PID list. Run the same code on startup.
这里有一些更安全的讨厌的方法：将每个子 PID 附加到一个文件，包括您的主进程（单独的文件）。使用文件锁定。构建一个看门狗守护进程，查看您的主 pid 的 flock() 状态。如果它没有被锁定，请杀死您子 PID 列表中的每个 PID。在启动时运行相同的代码。
More nasty: Write the PIDs to files, as above, then invoke your app in a sub-shell: (./myMaster; ./killMyChildren)
更讨厌：将 PID 写入文件，如上所述，然后在子 shell 中调用您的应用程序： (./myMaster; ./killMyChildren)
