Las tuberías con nombre son un método de comunicación FIFO entre procesos (también se les llama fifos). FIFO son las siglas de First In First Out, es decir, el primero que llega es que primero que se marcha, como en una cola, el primero que llega es el que antes termina.
Observad lo que hacen las macros depura_int y depura_string, nos darán el número de línea y el archivo donde están, así como el nombre de la variable y el valor que tiene en ese momento.
Normalmente las tuberías son anónimas, aunque el hecho de tenerlas con un nombre en nuestro sistema de ficheros puede sernos de gran utilidad. Como ejemplo, podemos verlo en funcionamiento en la siguiente imagen:
Cómo hacer una pipe con nombre en 1 minuto
Primero vemos el terminal de abajo, en el que se ejecuta lo siguiente:
1
2
| $ mkfifo prueba
$ cat prueba |
Seguidamente en el otro terminal se escribe lo siguiente:
1
| $ echo "Esto es una prueba" > prueba |
Automáticamente el texto “Esto es una prueba” aparece en el primer terminal. ¡Hemos logrado enviar un mensaje!
De la misma forma podemos programar aplicaciones que utilicen estas características de forma muy fácil en casi cualquier lenguaje de programación, para los ejemplos utilizaré C. Debemos hacer dos programas, uno que escriba en la tubería (pipe) y otro que lea de ella. Empezamos por pipewrite.c:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| #include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
int main ()
{
FILE *mipipe ;
char buffer [128];
int i =0;
if (mkfifo ("pipetest", S_IWUSR | /* El usuario puede escribir */
S_IRUSR | /* El usuario puede leer */
S_IRGRP | /* El grupo puede leer */
S_IROTH /* Otros pueden leer */
)!=0)
printf ("Hubo un problema al crear la pipe\n");
mipipe =fopen ("pipetest", "w"); /* Lo abrimos como un fichero normal y corriente */
/* Con esta línea leemos hasta que se cierre la tubería por el otro */
while (i <10)
{
sprintf (buffer , "CADENA ENVIADA Número: %i\n", i +1);
fputs (buffer , mipipe );
i ++;
}
fclose (mipipe ); /* Cerramos la tubería por aquí también */ |
Y ahora pipecilla.c (o el programa que leerá la pipe):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| #include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
int main ()
{
FILE *mipipe ;
char buffer [128];
if (mkfifo ("pipetest", S_IWUSR | /* El usuario puede escribir */
S_IRUSR | /* El usuario puede leer */
S_IRGRP | /* El grupo puede leer */
S_IROTH /* Otros pueden leer */
)!=0)
printf ("Hubo un problema al crear la pipe\n");
mipipe =fopen ("pipetest", "r"); /* Lo abrimos como un fichero normal y corriente */
/* Con esta línea leemos hasta que se cierre la tubería por el otro */
while (!feof (mipipe ))
{
if (fgets (buffer , 128, mipipe ))
printf ("RECIBIDO: %s", buffer );
}
fclose (mipipe ); /* Cerramos la tubería por aquí también */
} |
Ahora compilamos y ejecutamos en terminales diferentes de nuevo:
En el terminal de pipewrite.c, al ejecutar el programa da un mensaje de error, es porque la pipe ya existe (se creó en el programa anterior).
Esta forma de comunicación es unidireccional, puede ser últil por ejemplo para publicar el estado de un programa (un reproductor de audio podría publicar la canción que está sonando como en xmms-infopipe), o para modificar el comportamiento de un software mientras éste está en ejecución. Pero si queremos que nuestras aplicaciones dialoguen (en full-duplex), debemos tener dos pipes simultáneas, en ese caso, la aplicación 1, por ejemplo deberá leer en la tubería 1 y escribir en la tubería 2; y la aplicación 2, deberá escribir en la tubería 1 y leer en la tubería 2.
Últimos comentarios