Wie man Kindprozess sterben lässt, nachdem Elternteile verlassen?

Ich versuche, dieses problem zu lösen, und da mein Programm muss laufen auf OS X, Linux-only-Lösung funktionierte nicht für mich.

Kam ich zu dem gleichen Schluss wie die anderen Leute auf dieser Seite -- es gibt nicht einen POSIX-kompatiblen Art und Weise der Benachrichtigung ein Kind, wenn ein Elternteil stirbt. Also ich kludged bis die nächste beste Sache-das Kind poll.

Wenn ein Elternprozess stirbt (aus irgendeinem Grund) die Eltern-Prozess wird Prozess 1. Wenn das Kind einfach Umfragen in regelmäßigen Abständen überprüfen zu können, wenn das übergeordnete Element ist 1. Wenn es ist, sollte das Kind verlassen.

Dies ist nicht ideal, aber es funktioniert, und es ist einfacher, als die TCP-socket - /lockfile-polling Lösungen vorgeschlagen, an anderer Stelle auf dieser Seite.

InformationsquelleAutor der Antwort Schof

Wenn Sie nicht zu ändern, wird der Kind-Prozess, können Sie versuchen, so etwas wie die folgenden:

int pipes[2];
pipe(pipes)
if (fork() == 0) {
    close(pipes[1]); /* Close the writer end in the child*/
    dup2(0, pipes[0]); /* Use reader end as stdin */
    exec("sh -c 'set -o monitor; child_process & read dummy; kill %1'")
}

close(pipes[0]); /* Close the reader end in the parent */

Dies führt das Kind in einem shell-Prozess mit job-Steuerung aktiviert. Der Kind-Prozess erzeugt wird, in den hintergrund. Die shell wartet, bis ein newline (oder EOF), dann tötet das Kind.

Wenn der Elternteil stirbt-egal, was der Grund dafür-es wird in der Nähe seiner Ende der Leitung. Das Kind shell erhalten ein EOF vom Lesen und gehen Sie töten die im hintergrund Kind-Prozess.

InformationsquelleAutor der Antwort Phil Rutschman

Tut, wird der Kind-Prozess eine pipe nach/vom übergeordneten Prozess? Wenn ja, würden Sie erhalten ein SIGPIPE, wenn schreiben, oder bekommen EOF beim Lesen - diese Bedingungen nachgewiesen werden konnte.

InformationsquelleAutor der Antwort MarkR

Unter Linux installieren möchten, können Sie ein Eltern-Tod-Signals in das Kind, z.B.:

#include <sys/prctl.h>
#include <signal.h> //signals
#include <unistd.h> //fork()
#include <stdio.h>  //perror()

//...

pid_t ppid_before_fork = getpid();
pid_t pid = fork();
if (pid == -1) { perror(0); exit(1); }
if (pid) {
  ; //continue parent execution
} else {
  int r = prctl(PR_SET_PDEATHSIG, SIGTERM);
  if (r == -1) { perror(0); exit(1); }
  //test in case the original parent exited just
  //before the prctl() call
  if (getppid() != ppid_before_fork)
    exit(1);
  //continue child execution ...

Beachten Sie, dass die Speicherung der parent-Prozess-id, bevor Sie die Gabel und testen Sie in dem Kind nach prctl() beseitigt eine race-condition zwischen prctl() und den Ausgang des Prozesses, genannt das Kind.

Beachten Sie auch, dass die Eltern den Tod-signal für das Kind geklärt ist in neu erstellten Kinder von seiner eigenen. Es ist nicht betroffen von einem execve().

Die Prüfung kann vereinfacht werden, wenn wir sicher sind, dass der system-Prozess-wer ist verantwortlich für die Annahme aller Waisen hat die PID 1:

pid_t pid = fork();
if (pid == -1) { perror(0); exit(1); }
if (pid) {
  ; //continue parent execution
} else {
  int r = prctl(PR_SET_PDEATHSIG, SIGTERM);
  if (r == -1) { perror(0); exit(1); }
  //test in case the original parent exited just
  //before the prctl() call
  if (getppid() == 1)
    exit(1);
  //continue child execution ...

Vertrauen darauf, dass ein system-Prozess sein init und mit der PID 1 ist nicht tragbar, obwohl. POSIX.1-2008 gibt:

Den parent-Prozess-ID, der alle vorhandenen untergeordneten Prozesse und zombie-Prozesse des aufrufenden Prozesses wird auf die Prozess-ID des eine von der Implementierung definierte system-Prozess. Diese Prozesse müssen übernommen werden, die durch eine spezielle system-Prozess.

Traditionell, system-Prozess-Annahme aller Kinder ist die PID 1 hat, d.h. init - welches ist der Urahn aller Prozesse.

Auf moderne Systeme wie Linux oder FreeBSD einem anderen Prozess haben könnte, die Rolle. Zum Beispiel auf Linux, einen Prozess aufrufen kann prctl(PR_SET_CHILD_SUBREAPER, 1) etabliert sich als system-Prozess, der erbt alle Waisen seiner Nachkommen (vgl. ein Beispiel Fedora-25).

InformationsquelleAutor der Antwort maxschlepzig

Installieren trap-handler zu fangen, SIGINT, das tötet aus Ihrer Kind-Prozess, wenn es noch lebt, obwohl andere Poster korrekt sind, dass es sich nicht durchsetzen SIGKILL.

Öffnen .lockfile mit exklusivem Zugang und das Kind zu Umfrage, versuchen, Sie zu öffnen - wenn das öffnen erfolgreich, wird der Kind-Prozess sollte die Ausfahrt

InformationsquelleAutor der Antwort Paul Betts

Ich denke, eine schnelle und schmutzige Art und Weise ist das erstellen einer pipe zwischen Kind und Eltern. Wenn der parent beendet wird, Kinder erhalten ein SIGPIPE.

InformationsquelleAutor der Antwort Yefei

Einige Poster haben es bereits erwähnt-Rohre und -kqueue. In der Tat kann man auch ein paar der angeschlossenen Unix-domain-sockets durch die socketpair() nennen. Der socket-Typ sollte SOCK_STREAM.

Lassen Sie uns nehmen Sie an, Sie haben die zwei-socket-Datei-Deskriptoren fd1, fd2. Jetzt fork() erstellen der Kind-Prozess, die Erben der fds. In der übergeordneten, die Sie in der Nähe fd2 und in dem Kind, das Sie in der Nähe fd1. Nun, jeder Prozess kann poll() den noch offenen fd auf seinem eigenen Ende für die POLLIN Veranstaltung. Solange jede Seite muss nicht explizit close() seine fd während der normalen Lebensdauer, können Sie ziemlich sicher sein, dass ein POLLHUP Flagge zeigen sollte, dem anderen die Kündigung (egal, sauber oder nicht). Auf informiert diesem Fall ist, kann das Kind entscheiden, was zu tun ist (z.B. zu sterben).

#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <poll.h>
#include <stdio.h>

int main(int argc, char ** argv)
{
    int sv[2];        /* sv[0] for parent, sv[1] for child */
    socketpair(AF_UNIX, SOCK_STREAM, 0, sv);

    pid_t pid = fork();

    if ( pid > 0 ) {  /* parent */
        close(sv[1]);
        fprintf(stderr, "parent: pid = %d\n", getpid());
        sleep(100);
        exit(0);

    } else {          /* child */
        close(sv[0]);
        fprintf(stderr, "child: pid = %d\n", getpid());

        struct pollfd mon;
        mon.fd = sv[1];
        mon.events = POLLIN;

        poll(&mon, 1, -1);
        if ( mon.revents & POLLHUP )
            fprintf(stderr, "child: parent hung up\n");
        exit(0);
    }
}

Können Sie versuchen, kompilieren Sie die oben genannten proof-of-concept-code, und führen Sie es in ein terminal wie ./a.out &. Sie haben etwa 100 Sekunden zum Experimentieren mit der Tötung der Eltern-PID durch verschiedene Signale, oder es wird einfach zu beenden. In beiden Fällen sollten Sie sehen die Meldung "Kind: Eltern-hung up".

Verglichen mit der Methode, mit SIGPIPE handler diese Methode erfordert nicht versuchen, die write() nennen.

Diese Methode ist auch symmetrischend.h. die Prozesse können mit dem gleichen Kanal zu überwachen, den jeweils anderen Existenz.

Diese Lösung fordert nur die POSIX-Funktionen. Ich habe versucht, diese in Linux und FreeBSD. Ich denke, es sollte funktionieren, auf anderen Unices, aber ich habe nicht wirklich getestet.

Siehe auch:

• unix(7) Linux-man-Seiten, unix(4) für FreeBSD poll(2)socketpair(2)socket(7) auf Linux.

InformationsquelleAutor der Antwort Cong Ma

Wenn Sie senden ein signal an die pid 0, z.B. mit

kill(0, 2); /* SIGINT */

dass signal gesendet wird, um den gesamten Prozess der Gruppe, so effektiv zu töten das Kind.

Können Sie es testen, einfach mit etwas wie:

(cat && kill 0) | python

Wenn du dann die Taste ^D, du wirst sehen, der text "Terminated" als Indiz dafür, dass der Python-interpreter in der Tat getötet, anstatt nur verlassen, weil stdin geschlossen wurde.

InformationsquelleAutor der Antwort Thorbiörn Fritzon

Obwohl 7 Jahre vergangen, ich habe einfach dieses Problem, wie ich bin mit SpringBoot Anwendung starten muss, um webpack-dev-server während der Entwicklung und benötigt um es zu töten, wenn der backend-Prozess beendet.

Ich versuche es mal mit Runtime.getRuntime().addShutdownHook aber es hat funktioniert auf Windows 10 aber nicht auf Windows 7.

Habe ich es zu ändern verwenden Sie einen dedizierten thread, der wartet, bis der Prozess zu beenden oder für InterruptedException scheint, um korrekt zu funktionieren auf beiden Windows-Versionen.

private void startWebpackDevServer() {
    String cmd = isWindows() ? "cmd /c gradlew webPackStart" : "gradlew webPackStart";
    logger.info("webpack dev-server " + cmd);

    Thread thread = new Thread(() -> {

        ProcessBuilder pb = new ProcessBuilder(cmd.split(" "));
        pb.redirectOutput(ProcessBuilder.Redirect.INHERIT);
        pb.redirectError(ProcessBuilder.Redirect.INHERIT);
        pb.directory(new File("."));

        Process process = null;
        try {
            //Start the node process
            process = pb.start();

            //Wait for the node process to quit (blocking)
            process.waitFor();

            //Ensure the node process is killed
            process.destroyForcibly();
            System.setProperty(WEBPACK_SERVER_PROPERTY, "true");
        } catch (InterruptedException | IOException e) {
            //Ensure the node process is killed.
            //InterruptedException is thrown when the main process exit.
            logger.info("killing webpack dev-server", e);
            if (process != null) {
                process.destroyForcibly();
            }
        }

    });

    thread.start();
}

InformationsquelleAutor der Antwort Ido Ran

Fand ich 2 Lösungen, die beide nicht perfekt.

1.Töten Sie alle Kinder von kill (pid -), wenn empfangen SIGTERM-signal.

Natürlich kann diese Lösung nicht mit "kill -9", aber es tun sich für die meisten Gehäuse und sehr einfach, denn es müssen nicht an alle Kind-Prozesse.

    var childProc = require('child_process').spawn('tail', ['-f', '/dev/null'], {stdio:'ignore'});

    var counter=0;
    setInterval(function(){
      console.log('c  '+(++counter));
    },1000);

    if (process.platform.slice(0,3) != 'win') {
      function killMeAndChildren() {
        /*
        * On Linux/Unix(Include Mac OS X), kill (-pid) will kill process group, usually
        * the process itself and children.
        * On Windows, an JOB object has been applied to current process and children,
        * so all children will be terminated if current process dies by anyway.
        */
        console.log('kill process group');
        process.kill(-process.pid, 'SIGKILL');
      }

      /*
      * When you use "kill pid_of_this_process", this callback will be called
      */
      process.on('SIGTERM', function(err){
        console.log('SIGTERM');
        killMeAndChildren();
      });
    }

Durch den gleichen Weg, können Sie 'exit' - handler wie oben beschriebenen Weise, wenn Sie anrufen Prozess.Ausfahrt irgendwo.
Hinweis: Strg+C und plötzliche Absturz wurden automatisch verarbeitet, die von OS zu töten-Prozess-Gruppe, also nicht mehr hier.

2.Verwenden chjj/pty.jsum zu laichen, die Ihren Prozess mit controlling-terminal angehängt.

Wenn Sie zu töten Laufenden Prozess sowieso noch kill -9, alle Kind-Prozesse werden automatisch getötet zu werden (durch OS?). Ich denke, dass da die geltenden Verfahren halten andere Seite des Terminals, so dass, wenn der aktuelle Prozess stirbt, wird der Kind-Prozess bekommen SIGPIPE so stirbt.

    var pty = require('pty.js');

    //var term =
    pty.spawn('any_child_process', [/*any arguments*/], {
      name: 'xterm-color',
      cols: 80,
      rows: 30,
      cwd: process.cwd(),
      env: process.env
    });
    /*optionally you can install data handler
    term.on('data', function(data) {
      process.stdout.write(data);
    });
    term.write(.....);
    */

InformationsquelleAutor der Antwort osexp2003

Historisch aus der UNIX v7, der Prozess system hat erkannt, dass orphanity der Prozesse durch die überprüfung ein Prozess,' parent-id. Wie sage ich, dass, historisch gesehen, die init(8) system-Prozess ist ein spezieller Prozess, durch nur einen einzigen Grund: Es kann nicht sterben. Es kann nicht sterben, weil der kernel Algorithmus zum Umgang mit dem zuweisen einer neuen parent-Prozess-id, hängt von dieser Tatsache. wenn ein Prozess ein, führt die exit(2) Aufruf (durch einen Prozess, system call oder durch externe task sendet es ein signal oder dergleichen), der kernel ordnet alle Kinder in diesem Prozess die id des init-Prozess als Eltern-Prozess-id. Dies führt zu der die meisten einfachen test, und die meisten tragbaren Weg zu wissen, wenn ein Prozess hat Waisenkind. Nur überprüfen Sie das Ergebnis der getppid(2) - system nennen, und wenn es ist die Prozess-id des init(2) Prozess, dann wird der Prozess bekam Waise vor dem system-Aufruf.

Zwei Fragen ergeben sich aus diesem Ansatz, dass kann zu Problemen führen:

• ersten, wir haben die Möglichkeit der Veränderung der init Prozess zu jeder Benutzer-Prozess, Wie können wir also sicherstellen, dass der init-Prozess wird immer Eltern aller orphan-Prozesse? Gut, in der exit system-call-code, es gibt eine explizite überprüfen, um zu sehen, ob der Prozess der Ausführung der Aufruf der init-Prozess (der Prozess mit der pid, die gleich 1 ist) und wenn das der Fall ist, die kernel-Panik (Es sollte nicht in der Lage sein, mehr zur Aufrechterhaltung der Prozess-Hierarchie), so ist es nicht gestattet, für den init-Prozess zu tun, ein exit(2) nennen.
• zweiten, gibt es eine race-condition in der basic-test ausgesetzt oben. Init-Prozess' - id wird davon ausgegangen, historisch zu sein 1aber das ist garantiert nicht die POSIX-Ansatz, dass die Staaten (wie ausgesetzt in der anderen Antwort), dass nur ein system die Prozess-id reserviert für diesen Zweck. Fast keine posix-Implementierung der dies tut, und Sie können davon ausgehen, in der original-unix abgeleiteten Systemen, die mit 1 als Antwort getppid(2) system call ist genug, um davon ausgehen, der Prozess ist Waise. Ein weiterer Weg, um zu überprüfen ist es, eine getppid(2) nur nach der Gabel und vergleichen Sie diesen Wert mit dem Ergebnis, einen neuen Anruf. Dies ist einfach nicht in allen Fällen funktionieren, da beide nennen sind nicht atomar zusammen, und der übergeordnete Prozess sterben nach der fork(2) und vor dem ersten getppid(2) system nennen. Der Prozessparent id only changes once, when its parent does anexit(2)call, so this should be enough to check if thegetppid(2)result changed between calls to see that parent process has exit. This test is not valid for the actual children of the init process, because they are always children ofinit(8)`, aber Sie können sicher davon ausgehen, diese Prozesse als kein Elternteil entweder (außer, wenn Sie Ersatz in einem system der init-Prozess)

InformationsquelleAutor der Antwort Luis Colorado