如何以编程方式在启动它的同一脚本中终止正在运行的进程？

Question

How do I start processes from a script in a way that also allows me to terminate them?

Basically, I can easily terminate the main script, but terminating the external processes that this main script starts has been the issue. I googled like crazy for Perl 6 solutions. I was just about to post my question and then thought I'd open the question up to solutions in other languages.

Starting external processes is easy with Perl 6:

my $proc = shell("possibly_long_running_command");

shell returns a process object after the process finishes. So, I don't know how to programmatically find out the PID of the running process because the variable $proc isn't even created until the external process finishes. (side note: after it finishes, $proc.pid returns an undefined Any , so it doesn't tell me what PID it used to have.)

Here is some code demonstrating some of my attempts to create a "self destructing" script:

#!/bin/env perl6

say "PID of the main script: $*PID";

# limit run time of this script
Promise.in(10).then( {
    say "Took too long! Killing job with PID of $*PID";
    shell "kill $*PID"
} );

my $example = shell('echo "PID of bash command: $$"; sleep 20; echo "PID of bash command after sleeping is still $$"');

say "This line is never printed";

This results in the following output which kills the main script, but not the externally created process (see output after the word Terminated ):

[prompt]$ ./self_destruct.pl6
PID of the main script: 30432
PID of bash command: 30436
Took too long! Killing job with PID of 30432
Terminated
[prompt]$ my PID after sleeping is still 30436

By the way, the PID of sleep was also different (ie 30437 ) according to top .

I'm also not sure how to make this work with Proc::Async . Unlike the result of shell , the asynchronous process object it creates doesn't have a pid method.

I was originally looking for a Perl 6 solution, but I'm open to solutions in Python, Perl 5, Java, or any language that interacts with the "shell" reasonably well.

Answer 1

For Perl 6, there seems to be the Proc::Async module

Proc::Async allows you to run external commands asynchronously, capturing standard output and error handles, and optionally write to its standard input.

# command with arguments
my $proc = Proc::Async.new('echo', 'foo', 'bar');

# subscribe to new output from out and err handles:
$proc.stdout.tap(-> $v { print "Output: $v" });
$proc.stderr.tap(-> $v { print "Error:  $v" });

say "Starting...";
my $promise = $proc.start;

# wait for the external program to terminate
await $promise;
say "Done.";

Method kill:

kill(Proc::Async:D: $signal = "HUP")

Sends a signal to the running program. The signal can be a signal name ("KILL" or "SIGKILL"), an integer (9) or an element of the Signal enum (Signal::SIGKILL).

An example on how to use it:

#!/usr/bin/env perl6
use v6;

say 'Start';
my $proc = Proc::Async.new('sleep', 10);

my $promise= $proc.start;
say 'Process started';
sleep 2;
$proc.kill;
await $promise;
say 'Process killed';

As you can see, $proc has a method to kill the process.

Answer 2

既不是Perl，Perl 6，也不是Java，而是bash ：

 timeout 5 bash -c "echo hello; sleep 10; echo goodbye" &

Answer 3

In Java you can create a process like this:

ProcessBuilder processBuilder = new ProcessBuilder("C:\\Path\program.exe", "param1", "param2", "ecc...");
Process process = processBuilder.start(); // start the process

process.waitFor(timeLimit, timeUnit); // This causes the current thread to wait until the process has terminated or the specified time elapses

// when you want to kill the process
if(process.isAlive()) {
    process.destroy();
}

Or you can use process.destroyForcibly(); , see the Process documentation for more info.

To execute a bash command point to the bash executable and set the command as a parameter.