Come si chiama e senza nome tubo in Unix?

Nei sistemi simili a UNIX, i tubi sono un meccanismo per la comunicazione tra processo (IPC). Consentono a un processo di inviare dati a un altro processo. Esistono due tipi principali:tubi denominati (anche chiamati FIFOS) e tubi senza nome (chiamati anche tubi anonimi).

tubi senza nome (tubi anonimi):

* Creazione: Creato usando la chiamata di sistema `pipe ()`. Questa chiamata crea un tubo unidirezionale costituito da due descrittori di file:uno per la lettura (`fd [0]`) e uno per la scrittura (`fd [1]`).

* Accesso: Solo il processo che ha creato il tubo può accedervi. L'esistenza della pipa non è nota al di fuori del contesto del processo di creazione. In genere utilizzato per la comunicazione tra un processo genitore e figlio o tra due processi che sono esplicitamente collegati.

* Lifetime: Il tubo esiste solo per la vita dei processi che lo utilizzano. Quando uno dei due processi chiude la sua fine, il tubo viene automaticamente distrutto e qualsiasi ulteriore tentativo di leggere o scrivere fallirà.

* Esempio (usando `fork ()` e `pipe ()`):

`` `c

#include

int main () {

int fd [2]; // File descrittori per il tubo

pid_t pid;

if (pipe (fd) ==-1) {

perror ("pipe non riuscita");

uscita (1);

}

pid =fork ();

if (pid <0) {

perror ("fork fallito");

uscita (1);

} else if (pid ==0) {// processo figlio

chiudere (fd [1]); // Chiudi la fine della scrittura

Char Buffer [100];

leggi (fd [0], buffer, sizeof (buffer));

printf ("bambino ricevuto:%s \ n", buffer);

chiudere (fd [0]);

} else {// Processo genitore

chiudere (fd [0]); // Chiudi la fine di lettura

const char* messaggio ="ciao dal genitore!";

scrivere (fd [1], messaggio, strlen (messaggio) + 1); // +1 per null Terminator

chiudere (fd [1]);

wait (null); // Aspetta che il bambino finisca

}

restituzione 0;

}

`` `

Pipes (FIFOS):

* Creazione: Creato usando la chiamata di sistema `mkfifo (). Questo crea un file nel filesystem che rappresenta il tubo. Il nome del file funge da identificatore per il tubo.

* Accesso: Più processi possono accedere a un tubo chiamato. Qualsiasi processo che conosca il percorso del tubo può aprirlo per la lettura o la scrittura (anche se solo un processo può scrivere alla volta, a meno che non si utilizzi configurazioni speciali). Sopravvivono oltre la vita dei processi usandoli.

* Lifetime: Il tubo persiste nel filesystem fino a quando non è stato eliminato esplicitamente usando `Unlink ()`.

* Esempio (utilizzando due programmi separati che comunicano attraverso un tubo chiamato):

Avresti bisogno di due programmi:uno per scrivere al FIFO e un altro da leggere da esso. `mkfifo ()` è chiamato una volta (forse in uno script di configurazione) per creare il FIFO, quindi i programmi `aperti ()` il FIFO per leggere/scrivere. I processi devono gestire errori tra cui la possibilità del FIFO non esistente e gli errori su `Open ()`.

Differenze chiave riassunte:

| Caratteristica | Pipe senza nome | Chiamato Pipe (FIFO) |

| ----------------- | ---------------------------- | --------------------------------- |

| Creazione | `pipe ()` | `mkfifo ()` |

| Accesso | Solo creazione di processo | Processi multipli |

| Persistenza | Esiste solo durante la vita del processo | Persiste nel filesystem |

| Inter-Process | Di solito processi genitore-figlio o esplicitamente connessi | Può connettere processi non correlati |

| Voce del file system | No | Sì |

I tubi nominati sono più flessibili per la comunicazione tra processi non correlati, mentre i tubi senza nome sono più semplici ed efficienti per la comunicazione tra processi strettamente correlati come un genitore e il suo figlio. La scelta dipende dalle esigenze di comunicazione specifiche dell'applicazione.

Come si chiama e senza nome tubo in Unix?

Informazioni correlate

Articoli consigliati