Pipe
Comunicazione tra processo padre e figlio
Pipe è una lezione C Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C Academy include 4 lezioni in totale.
Che cos'è una pipe
Una pipe è un canale di comunicazione unidirezionale tra processi correlati. Un processo vi scrive dei byte e un altro li legge, come su un nastro trasportatore di dati.
Due descrittori di file
La chiamata pipe() riempie un array di due elementi: fd[0] è l'estremità di lettura e fd[1] quella di scrittura. I dati scritti in fd[1] possono essere letti da 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;
}Combinare con fork
Dopo fork(), il processo padre e quello figlio condividono i descrittori della pipe. È così che comunicano: uno scrive e l'altro legge.
Chiudere le estremità inutilizzate
Ogni processo dovrebbe chiudere l'estremità che non utilizza. Un lettore chiude l'estremità di scrittura; uno scrittore chiude quella di lettura. Altrimenti il lettore non rileverà mai la fine del file.
#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 esempio padre-figlio
Il processo padre scrive un messaggio; il processo figlio lo legge. Ciascuno chiude l'estremità di cui non ha bisogno.
#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 lettura restituisce EOF
Quando tutte le estremità di scrittura sono chiuse, read restituisce 0, indicando la fine del file. Se un'estremità di scrittura rimane aperta, il lettore resta bloccato aspettando altri dati per sempre: è un errore comune.
Capacità della pipe e blocco
Una pipe ha un buffer di dimensioni finite (spesso 64 KB). Se si riempie, write si blocca finché un lettore non lo svuota. Se è vuoto, read si blocca finché non arrivano dati. Questo controllo del flusso sincronizza i due processi.
Reindirizzare con dup2
dup2 può sostituire lo stdin o lo stdout di un processo con un'estremità della pipe. È così che le shell implementano cmd1 | cmd2, collegando l'output di un comando all'input del successivo.
#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]);
}Pipe con nome (FIFO)
Una pipe ordinaria collega solo processi correlati. Una pipe con nome (FIFO), creata con mkfifo, compare nel filesystem, consentendo a processi non correlati di aprirla tramite il percorso e comunicare.
#include <sys/stat.h>
int make_fifo(const char *path) {
return mkfifo(path, 0666); /* creates a FIFO file */
}Pericolo di SIGPIPE
La scrittura in una pipe la cui estremità di lettura è chiusa genera SIGPIPE, che per impostazione predefinita termina il processo. Ignori il segnale oppure verifichi l'errore EPIPE restituito da write.
Quando utilizzare le pipe
Le pipe sono ideali per lo streaming semplice e unidirezionale tra un processo padre e uno figlio, oppure per concatenare programmi. Per la comunicazione bidirezionale o tra processi non correlati, consideri FIFO, socket o memoria condivisa.
Verifica rapida
Verifichi la Sua comprensione delle pipe.
Riepilogo
Ha imparato a utilizzare le pipe per la comunicazione tra processi padre e figlio.
pipe()fornisce fd[0] (lettura) e fd[1] (scrittura)- Le combini con
fork; chiuda le estremità inutilizzate - read restituisce 0 alla fine del file quando tutte le estremità di scrittura sono chiuse
- Le FIFO collegano processi non correlati; presti attenzione a SIGPIPE
Impara C con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 39
- Lezioni
- 144
Domande Frequenti
La lezione «Pipe» è gratuita?
Sì — il testo completo di «Pipe» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C Academy, passa a CoddyKit PRO. Il corso C Academy include 4 lezioni in totale.
Cosa imparerò in «Pipe»?
Comunicazione tra processo padre e figlio Eserciti C Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare C Academy?
Non è richiesta alcuna esperienza precedente. C Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Pipe»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione C Academy?
Sì. Ogni lezione C Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.