Tuberías
Comunicación entre procesos padre e hijo
Tuberías es una lección gratuita de C Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.
Qué es una tubería
Una tubería es un canal de comunicación unidireccional entre procesos relacionados. Un proceso escribe bytes en ella y otro los lee, como si se tratara de una cinta transportadora de datos.
Dos descriptores de archivo
La llamada pipe() rellena un array de dos elementos: fd[0] es el extremo de lectura y fd[1] es el extremo de escritura. Los datos escritos en fd[1] pueden leerse desde fd[0].
#include <unistd.h>
#include <stdio.h>
int make_pipe(int fd[2]) {
if (pipe(fd) < 0) { perror("pipe"); return -1; }
/* fd[0] read end, fd[1] write end */
return 0;
}Combinar con fork
Después de fork(), tanto el proceso padre como el hijo comparten los descriptores de la tubería. Así se comunican un padre y un hijo: uno escribe y el otro lee.
Cerrar los extremos no utilizados
Cada proceso debe cerrar el extremo que no utiliza. El lector cierra el extremo de escritura y el escritor cierra el extremo de lectura. De lo contrario, el lector nunca detectará el fin de archivo.
#include <unistd.h>
void parent_as_writer(int fd[2]) {
close(fd[0]); /* parent will not read */
write(fd[1], "hello", 5); /* parent writes */
close(fd[1]); /* signal EOF to reader */
}Un ejemplo de padre e hijo
El padre escribe un mensaje y el hijo lo lee. Cada uno cierra el extremo que no necesita.
#include <unistd.h>
#include <stdio.h>
void demo(int fd[2]) {
if (fork() == 0) { /* child: reader */
close(fd[1]);
char buf[64];
ssize_t n = read(fd[0], buf, sizeof buf - 1);
buf[n] = 0;
printf("child got: %s\n", buf);
close(fd[0]);
} else { /* parent: writer */
close(fd[0]);
write(fd[1], "hi child", 8);
close(fd[1]);
}
}La lectura devuelve EOF
Cuando se cierran todos los extremos de escritura, read devuelve 0, lo que indica el fin de archivo. Si un extremo de escritura permanece abierto, el lector se bloquea esperando más datos indefinidamente; es un error habitual.
Capacidad y bloqueo de las tuberías
Una tubería tiene un búfer de tamaño limitado (a menudo, 64 KB). Si se llena, write se bloquea hasta que un lector lo vacía. Si está vacío, read se bloquea hasta que llegan datos. Este control de flujo sincroniza ambos procesos.
Redirección con dup2
dup2 puede sustituir la entrada estándar o la salida estándar de un proceso por un extremo de una tubería. Así es como los shells implementan cmd1 | cmd2, conectando la salida de un comando con la entrada del siguiente.
#include <unistd.h>
void stdout_to_pipe(int fd[2]) {
close(fd[0]);
dup2(fd[1], STDOUT_FILENO); /* writes to stdout go into pipe */
close(fd[1]);
}Tuberías con nombre (FIFO)
Una tubería normal solo conecta procesos relacionados. Una tubería con nombre (FIFO), creada con mkfifo, aparece en el sistema de archivos, por lo que los procesos no relacionados pueden abrirla mediante su ruta y comunicarse.
#include <sys/stat.h>
int make_fifo(const char *path) {
return mkfifo(path, 0666); /* creates a FIFO file */
}Riesgo de SIGPIPE
Escribir en una tubería cuyo extremo de lectura está cerrado genera SIGPIPE, que de forma predeterminada termina el proceso. Puede ignorar la señal o comprobar el error EPIPE devuelto por write.
Cuándo usar tuberías
Las tuberías son ideales para transmitir datos de forma sencilla y unidireccional entre un proceso padre y uno hijo, o para encadenar programas. Para la comunicación bidireccional o entre procesos no relacionados, considere usar FIFO, sockets o memoria compartida.
Comprobación rápida
Compruebe su comprensión de las tuberías.
Resumen
Ha aprendido a utilizar tuberías para la comunicación entre procesos padre e hijo.
pipe()proporciona fd[0] (lectura) y fd[1] (escritura)- Combínela con
forky cierre los extremos no utilizados - read devuelve 0 al alcanzar EOF cuando se cierran todos los extremos de escritura
- Las FIFO conectan procesos no relacionados; tenga cuidado con SIGPIPE
Preguntas frecuentes
¿La lección «Tuberías» es gratis?
Sí — el texto completo de «Tuberías» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Tuberías»?
Comunicación entre procesos padre e hijo Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C Academy?
No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Tuberías»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C Academy?
Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.