Esperar llamada al sistema en C

Requisito previo: Llamada al sistema de bifurcación
Una llamada a wait() bloquea el proceso de llamada hasta que uno de sus procesos secundarios finaliza o se recibe una señal. Después de que finaliza el proceso hijo, el padre continúa su ejecución después de esperar la instrucción de llamada al sistema. 
El proceso secundario puede terminar debido a cualquiera de estos: 

• Llama a salir();
• Devuelve (un int) de main
• Recibe una señal (del sistema operativo o de otro proceso) cuya acción predeterminada es terminar.
   

Sintaxis en lenguaje c: 

#include
#include

// take one argument status and returns 
// a process ID of dead children.
pid_t wait(int *stat_loc);   

Si algún proceso tiene más de un proceso secundario, luego de llamar a wait(), el proceso principal debe estar en estado de espera si no finaliza ningún proceso secundario. 
Si solo se finaliza un proceso secundario, devolver una espera() devuelve el ID de proceso del proceso secundario terminado. 
Si se finaliza más de un proceso secundario, wait() cosecha cualquier elemento secundario arbitrariamente y devuelve una ID de proceso de ese proceso secundario. 
Cuando wait() regresa, también definen el estado de salida (que le dice a nuestro, un proceso por qué terminó) a través del puntero, si el estado no es NULL .
Si algún proceso no tiene un proceso secundario, wait() devuelve inmediatamente «-1».
NOTA: «Este código no se ejecuta en IDE simple debido a un problema ambiental, así que use la terminal para ejecutar el código» 
Ejemplos: 

// C program to demonstrate working of wait()
#include<stdio.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<unistd.h>
 
int main()
{
    pid_t cpid;
    if (fork()== 0)
        exit(0);           /* terminate child */
    else
        cpid = wait(NULL); /* reaping parent */
    printf("Parent pid = %d\n", getpid());
    printf("Child pid = %d\n", cpid);
 
    return 0;
}

Producción: 
 

Parent pid = 12345678 
Child pid = 89546848 

// C program to demonstrate working of wait()
#include<stdio.h>
#include<sys/wait.h>
#include<unistd.h>
 
int main()
{
    if (fork()== 0)
        printf("HC: hello from child\n");
    else
    {
        printf("HP: hello from parent\n");
        wait(NULL);
        printf("CT: child has terminated\n");
    }
 
    printf("Bye\n");
    return 0;
}

Salida: depende del entorno 

HC: hello from child
Bye
HP: hello from parent
CT: child has terminated
     (or)
HP: hello from parent
HC: hello from child
HC: Bye
CT: child has terminated    // this sentence does 
                            // not print before HC 
                            // because of wait.
Bye

Información de estado del niño: La información 
de estado sobre el niño reportada por wait es más que solo el estado de salida del niño, también incluye 

• terminación normal/anormal
• causa de terminación
• estado de salida

Para encontrar información sobre el estado, usamos 
WIF ….macros
1. WIFEXITED(status) : el niño salió normalmente 
• WEXITSTATUS(status) : código de retorno cuando el niño sale
2. WIFSIGNALED(status) : el niño salió porque no se captó una señal 
• WTERMSIG (estado) : da el número de la señal de terminación
3. WIFSTOPPED(estado) : el niño está detenido 
• WSTOPSIG(estado) : da el número de la señal de parada

/*if we want to prints information about a signal */
void psignal(unsigned sig, const char *s);

Ejemplos: 
Compruebe la salida del siguiente programa. 

// C program to demonstrate working of status
// from wait.
#include<stdio.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<unistd.h>
 
void waitexample()
{
    int stat;
 
    // This status 1 is reported by WEXITSTATUS
    if (fork() == 0)
        exit(1);
    else
        wait(&stat);
    if (WIFEXITED(stat))
        printf("Exit status: %d\n", WEXITSTATUS(stat));
    else if (WIFSIGNALED(stat))
        psignal(WTERMSIG(stat), "Exit signal");
}
 
// Driver code
int main()
{
    waitexample();
    return 0;
}

Producción: 

Exit status: 1              

Sabemos que si se finaliza más de un proceso hijo, entonces wait() cosecha cualquier proceso hijo arbitrariamente, pero si queremos cosechar cualquier proceso hijo específico, usamos la función waitpid() .

Sintaxis en lenguaje c: 
pid_t waitpid (child_pid, &status, options);

Parámetro de opciones 

• Si 0 significa que no hay opción, el padre tiene que esperar a que finalice el hijo.
• Si WNOHANG significa que el padre no espera si el hijo no termina, simplemente verifique y devuelva waitpid(). (No bloquee el proceso principal)
• Si child_pid es -1 , entonces significa cualquier niño arbitrariamente , aquí waitpid() funciona igual que wait().

Valor de retorno de waitpid() 

• pid del niño, si el niño ha salido
• 0, si usa WNOHANG y el niño no ha salido.

// C program to demonstrate waitpid()
#include<stdio.h>
#include<stdlib.h>
#include<sys/wait.h>
#include<unistd.h>
 
void waitexample()
{
    int i, stat;
    pid_t pid[5];
    for (i=0; i<5; i++)
    {
        if ((pid[i] = fork()) == 0)
        {
            sleep(1);
            exit(100 + i);
        }
    }
 
    // Using waitpid() and printing exit status
    // of children.
    for (i=0; i<5; i++)
    {
        pid_t cpid = waitpid(pid[i], &stat, 0);
        if (WIFEXITED(stat))
            printf("Child %d terminated with status: %d\n",
                   cpid, WEXITSTATUS(stat));
    }
}
 
// Driver code
int main()
{
    waitexample();
    return 0;
}

Producción: 

Child 50 terminated with status: 100
Child 51 terminated with status: 101
Child 52 terminated with status: 102
Child 53 terminated with status: 103
Child 54 terminated with status: 104

Aquí, los pid de los niños dependen del sistema, pero para imprimir toda la información del niño. 
Este artículo es una contribución de Kadam Patel . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.