如何让fork创建的C语言子进程仅执行指定函数后退出？

Hey there! I get what you're trying to do—when you use fork() in C, the child process starts running right after the fork() call, which means it'll follow the same code path as the parent unless you explicitly redirect it. Let's fix this with a straightforward approach.

The Core Idea #

When fork() is called:

• The parent process gets the child's PID as the return value
• The child process gets 0 as the return value
• If fork() fails, it returns -1

We can use this return value to split the execution flow: in the child's branch, we run our target function, then immediately terminate the child so it doesn't execute any of the parent's subsequent code.

Example Code #

Here's a complete working example:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

// Your custom function that the child should run
void my_specific_function() {
    printf("Child process: Running the specific function!\n");
    // Add your function logic here—file I/O, computations, etc.
}

int main() {
    pid_t child_pid = fork();

    if (child_pid == -1) {
        // Handle fork failure
        perror("Failed to create child process");
        exit(EXIT_FAILURE);
    } 
    else if (child_pid == 0) {
        // This is the CHILD process
        my_specific_function();
        // Terminate the child immediately after the function finishes
        exit(EXIT_SUCCESS);
    } 
    else {
        // This is the PARENT process
        printf("Parent process: Waiting for child to finish...\n");
        // Wait for the child to terminate to avoid zombie processes
        wait(NULL);
        printf("Parent process: Child has finished execution.\n");
    }

    // Only the parent will reach this line
    printf("Parent process: Continuing with its own tasks.\n");
    return 0;
}

Key Details to Note #

• Explicit Termination: Using exit(EXIT_SUCCESS) in the child branch ensures that after your function runs, the child doesn't proceed to execute the rest of the main() function. You could also use return 0; here, but exit() is more explicit and works even if your function is called from somewhere other than main.
• Avoid Zombie Processes: The wait(NULL) call in the parent tells it to pause until the child exits. Without this, the child would become a "zombie process" (a terminated process that still has an entry in the process table) until the parent exits.
• Function Arguments: If your target function needs parameters, just pass them like you would in any normal function call—since the child has a copy of the parent's address space, it can access all variables the parent had at the time of fork().

What If My Function Already Exits? #

If your specific function already calls exit() or has a return that terminates execution, you can skip the extra exit() in the child branch. But it's still a good practice to include it to make your intent clear, especially if someone else might modify the function later.

内容的提问来源于stack exchange，提问作者MCS97