How to kill a child process by the parent process?

In operating systems, the parent process can control and manage the child processes it creates, including terminating their execution. This operation is commonly implemented using specific system calls or signals. Below are several common methods to kill child processes via the parent process:

1. Using Signals (with Linux as an example)

In Linux systems, the parent process can terminate the child process by sending signals. The most commonly used signals are SIGKILL and SIGTERM.

• SIGKILL (Signal 9): This is a forced signal used to immediately terminate the child process. The child process cannot ignore this signal.
• SIGTERM (Signal 15): This is a graceful termination signal used to request the child process to exit. The child process can catch this signal to perform cleanup operations before exiting.

Example:

Assume the parent process knows the PID (Process ID) of the child process; it can use the kill command to send signals:

bash
kill -SIGTERM <child-pid>

If the child process does not respond to SIGTERM, it can use:

bash
kill -SIGKILL <child-pid>

2. Using System Calls

In programming, such as using C language, the kill() function can be called to send signals.

Example code:

c
#include <sys/types.h>
#include <signal.h>
#include <stdio.h>

int main() {
    pid_t child_pid;

    // Create child process
    child_pid = fork();

    if (child_pid == 0) {
        // Child process code
        while(1) {
            printf("I am the child process.
");
            sleep(1);
        }
    } else {
        // Parent process code
        sleep(5);  // For example, wait 5 seconds
        kill(child_pid, SIGTERM);  // Send SIGTERM signal
        printf("SIGTERM signal sent to child process.
");
    }

    return 0;
}

3. Using Advanced Programming Techniques

In some advanced programming languages, such as Python or Java, child processes can be terminated by calling library functions or methods.

Python Example:

python
import subprocess
import time

# Create child process
p = subprocess.Popen(["sleep", "30"])

# Wait for a period
time.sleep(5)

# Kill child process
p.terminate()  # Prefer to use terminate()
if p.poll() is None:  # If child process is still running
    p.kill()  # Force kill

In practical operations, it is recommended to first send the SIGTERM signal to allow the child process to perform necessary cleanup operations. If the child process does not respond within a reasonable time, then send the SIGKILL signal. This approach is both forceful and controlled, facilitating the graceful release and management of resources.