Hey there! I totally get where you're coming from—fork() and process management in C can feel like navigating a maze at first, especially when functions like wait() don't behave exactly how you expect. Let's break this down clearly.

First, let's cover the core of what wait() does:

• The wait() system call pauses the parent process's execution until one of its child processes terminates (or a signal interrupts the wait).
• When a child exits, the OS doesn't immediately clean up all its resources. It keeps a small "zombie" process entry with details like the child's exit status. The parent has to call wait() to collect this status, which tells the OS it can fully delete that child's process data.

Now, let's go over the most common gotchas that might be causing unexpected behavior in your code (even though your snippet cuts off, these are the top culprits for wait() confusion):

• Only waiting for one child, not all
  If you're forking multiple children (your #define N 10 hints at this), a single wait() call will only wait for the first child to finish. To wait for every child, you need to loop wait() until it returns -1 (with errno set to ECHILD, meaning no more children are left to wait on).
• Ignoring the return value and status
  wait() gives you two key pieces of info: its return value is the PID of the terminated child, and if you pass a status pointer, you can use macros like WIFEXITED(status) to check if the child exited normally, or WEXITSTATUS(status) to get the exit code it returned. Skipping this means you're missing critical context about why the child stopped.
• Signals breaking the wait
  If the parent gets a signal (like SIGINT from Ctrl+C) while blocked in wait(), the function will exit early with -1 and set errno to EINTR. You might need to handle this by restarting the wait() call if this happens.

Let's walk through a complete example that mirrors what you're probably building, to make this concrete:

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

#define N 10

int main() {
    int i;
    pid_t pid;

    // Fork 10 child processes
    for (i = 0; i < N; i++) {
        pid = fork();
        if (pid == -1) {
            perror("fork failed");
            exit(EXIT_FAILURE);
        } else if (pid == 0) {
            // Child process: simulate work then exit
            printf("Child %d (PID: %d) starting work\n", i, getpid());
            sleep(1); // Fake work task
            exit(i); // Pass child index as exit status
        }
        // Parent moves on to fork next child
    }

    // Parent waits for every child to finish
    int status;
    pid_t terminated_child_pid;
    while ((terminated_child_pid = wait(&status)) != -1) {
        if (WIFEXITED(status)) {
            printf("Child PID %d exited normally with code %d\n", 
                   terminated_child_pid, WEXITSTATUS(status));
        } else {
            printf("Child PID %d exited unexpectedly (crashed or was killed)\n", terminated_child_pid);
        }
    }

    // Verify wait() stopped because no children are left
    if (errno != ECHILD) {
        perror("wait encountered an error");
        exit(EXIT_FAILURE);
    }

    printf("All children have finished. Parent process exiting.\n");
    return 0;
}

In this code:

• We loop to create 10 child processes, each doing a quick simulated task before exiting.
• The parent uses a while loop with wait() to catch every child as it exits—no zombies left behind.
• We use the status macros to get clear details about how each child ended its run.

If your original code was acting weird, it's almost certainly one of these scenarios: maybe you didn't loop wait() for all children, or you didn't check the exit status to understand what your kids were up to. Feel free to share the rest of your code if you want a hyper-specific deep dive into your exact case!

内容来源于stack exchange