tubería() Llamada al sistema

Requisito previo: llamadas al sistema de E/S

Conceptualmente, una tubería es una conexión entre dos procesos, de modo que la salida estándar de un proceso se convierte en la entrada estándar del otro proceso. En el sistema operativo UNIX, las tuberías son útiles para la comunicación entre procesos relacionados (comunicación entre procesos).

• La tubería es una comunicación unidireccional, es decir, podemos usar una tubería de modo que un proceso escriba en la tubería y el otro proceso lea desde la tubería. Abre una tubería, que es un área de la memoria principal que se trata como un «archivo virtual» .
• La tubería puede ser utilizada por el proceso de creación, así como por todos sus procesos secundarios, para leer y escribir. Un proceso puede escribir en este «archivo virtual» o tubería y otro proceso relacionado puede leerlo.
• Si un proceso intenta leer antes de que se escriba algo en la canalización, el proceso se suspende hasta que se escriba algo.
• La llamada al sistema de tuberías encuentra las dos primeras posiciones disponibles en la tabla de archivos abiertos del proceso y las asigna para los extremos de lectura y escritura de la tubería.


Sintaxis en lenguaje C:

int pipe(int fds[2]);

Parameters :
fd[0] will be the fd(file descriptor) for the 
read end of pipe.
fd[1] will be the fd for the write end of pipe.
Returns : 0 on Success.
-1 on error.

Las tuberías se comportan FIFO (primero en entrar, primero en salir), las tuberías se comportan como una estructura de datos de cola . El tamaño de lectura y escritura no tiene que coincidir aquí. Podemos escribir 512 bytes a la vez, pero solo podemos leer 1 byte a la vez en una tubería.

// C program to illustrate
// pipe system call in C
#include <stdio.h>
#include <unistd.h>
#define MSGSIZE 16
char* msg1 = "hello, world #1";
char* msg2 = "hello, world #2";
char* msg3 = "hello, world #3";
  
int main()
{
    char inbuf[MSGSIZE];
    int p[2], i;
  
    if (pipe(p) < 0)
        exit(1);
  
    /* continued */
    /* write pipe */
  
    write(p[1], msg1, MSGSIZE);
    write(p[1], msg2, MSGSIZE);
    write(p[1], msg3, MSGSIZE);
  
    for (i = 0; i < 3; i++) {
        /* read pipe */
        read(p[0], inbuf, MSGSIZE);
        printf("% s\n", inbuf);
    }
    return 0;
}

Producción:

hello, world #1
hello, world #2
hello, world #3

Padre e hijo compartiendo una pipa

Cuando usamos bifurcación en cualquier proceso, los descriptores de archivo permanecen abiertos en el proceso secundario y también en el proceso principal. Si llamamos a fork después de crear una tubería, entonces el padre y el hijo pueden comunicarse a través de la tubería.

Salida del siguiente programa.

// C program to illustrate
// pipe system call in C
// shared by Parent and Child
#include <stdio.h>
#include <unistd.h>
#define MSGSIZE 16
char* msg1 = "hello, world #1";
char* msg2 = "hello, world #2";
char* msg3 = "hello, world #3";
  
int main()
{
    char inbuf[MSGSIZE];
    int p[2], pid, nbytes;
  
    if (pipe(p) < 0)
        exit(1);
  
    /* continued */
    if ((pid = fork()) > 0) {
        write(p[1], msg1, MSGSIZE);
        write(p[1], msg2, MSGSIZE);
        write(p[1], msg3, MSGSIZE);
  
        // Adding this line will
        // not hang the program
        // close(p[1]);
        wait(NULL);
    }
  
    else {
        // Adding this line will
        // not hang the program
        // close(p[1]);
        while ((nbytes = read(p[0], inbuf, MSGSIZE)) > 0)
            printf("% s\n", inbuf);
        if (nbytes != 0)
            exit(2);
        printf("Finished reading\n");
    }
    return 0;
}

Producción:

hello world, #1
hello world, #2
hello world, #3
(hangs)         //program does not terminate but hangs

Aquí, en este código Después de terminar de leer/escribir, tanto el padre como el hijo se bloquean en lugar de terminar el proceso y es por eso que el programa se bloquea. Esto sucede porque la llamada al sistema de lectura obtiene la cantidad de datos que solicita o la cantidad de datos que tiene la canalización, lo que sea menor.

• Si la tubería está vacía y llamamos al sistema de lectura, las lecturas en la tubería devolverán EOF (valor de retorno 0) si ningún proceso tiene el extremo de escritura abierto.
• Si algún otro proceso tiene la canalización abierta para escritura, la lectura se bloqueará en previsión de nuevos datos, por lo que la salida de este código se bloquea porque aquí la escritura finaliza el proceso principal y el proceso secundario no se cierra.

Para obtener más detalles sobre cómo compartir tubería entre padres e hijos, consulte el programa C para demostrar fork() y pipe() .
 
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.