Phenquestions
Um tubo é um meio de comunicação entre processos. Um processo grava dados no tubo, e outro processo lê os dados do tubo. Neste artigo, veremos como a função pipe () é usada para implementar o conceito usando a linguagem C.
Sobre o Pipe
No tubo, os dados são mantidos em uma ordem FIFO, o que significa gravar dados em uma extremidade do tubo sequencialmente e ler dados de outra extremidade do tubo na mesma ordem sequencial.
Se algum processo for lido pelo canal, mas nenhum outro processo ainda não tiver sido gravado no canal, a leitura retornará o fim do arquivo. Se um processo deseja gravar em um tubo, mas não há outro processo conectado ao tubo para leitura, então esta é uma condição de erro, e o tubo gera um sinal SIGPIPE.
Arquivo de cabeçalho
#incluirSintaxe
int pipe (int filedes [2])Argumentos
Esta função recebe um único argumento, uma matriz de dois inteiros (filedes). filedes [0] é usado para leitura do tubo, e filedes [1] é usado para escrever no tubo. O processo que deseja ler a partir do tubo deve fechar filedes [1], e o processo que deseja escrever no tubo deve fechar filedes [0]. Se as extremidades desnecessárias do tubo não forem fechadas explicitamente, o fim do arquivo (EOF) nunca será retornado.
Valores de retorno
Com sucesso, o tubo() retorna 0, em caso de falha a função retorna -1.
Pictorialmente, podemos representar o tubo() funcionar da seguinte forma:
Abaixo estão alguns exemplos que descrevem como usar a função pipe em linguagem C.
Exemplo 1
Neste exemplo, veremos como funciona a função de tubo. Embora usar um pipe em um único processo não seja muito útil, mas teremos uma ideia.
// Exemplo 1.c#incluir
#incluir
#incluir
#incluir
int main ()
int n;
int filedes [2];
buffer char [1025];
char * message = "Olá, mundo!";
cachimbo (filedes);
escrever (filedes [1], mensagem, strlen (mensagem));
if ((n = ler (filedes [0], buffer, 1024))> = 0)
buffer [n] = 0; // termina a string
printf ("ler% d bytes do tubo:"% s "\ n", n, buffer);
senão
perror ("ler");
saída (0);
Aqui, primeiro criamos um tubo usando tubo() função, em seguida, escrito para o tubo usando fildes [1] fim. Então, os dados foram lidos usando a outra extremidade do tubo, que é filedes [0]. Para ler e gravar no arquivo, costumávamos leitura() e Escreva() funções.
Exemplo 2
Neste exemplo, veremos como os processos pai e filho se comunicam usando o tubo.
// Exemplo2.c#incluir
#incluir
#incluir
#incluir
#incluir
int main ()
int filedes [2], nbytes;
pid_t childpid;
char string [] = "Olá, mundo!\ n ";
char readbuffer [80];
cachimbo (filedes);
if ((childpid = fork ()) == -1)
perror ("garfo");
saída (1);
if (childpid == 0)
close (filedes [0]); // O processo filho não precisa dessa extremidade do tubo
/ * Enviar "string" pelo lado de saída do tubo * /
escrever (filedes [1], string, (strlen (string) +1));
saída (0);
senão
/ * O processo pai fecha o lado de saída do tubo * /
close (filedes [1]); // O processo pai não precisa dessa extremidade do tubo
/ * Leia em uma string a partir do tubo * /
nbytes = ler (filedes [0], readbuffer, sizeof (readbuffer));
printf ("Ler string:% s", readbuffer);
return (0);
Primeiro, um canal foi criado usando a função de canal, em seguida, um processo filho foi bifurcado. Em seguida, o processo filho fecha a extremidade de leitura e grava no tubo. O processo pai fecha a extremidade de gravação e lê a partir do tubo e o exibe. Aqui, o fluxo de dados é apenas uma maneira que vai do filho para o pai.
Conclusão:
tubo() é uma chamada de sistema poderosa no Linux. Neste artigo, vimos apenas um fluxo de dados unilateral, um processo grava e outro processo lê, criando dois canais que podemos alcançar o fluxo de dados bidirecional também.
