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 ler a partir do pipe, mas nenhum outro processo ainda não tiver gravado no pipe, então read retorna o fim do arquivo. Se um processo deseja gravar em um pipe, mas não há outro processo conectado ao pipe para leitura, então esta é uma condição de erro e o pipe gera um sinal SIGPIPE.
Arquivo de cabeçalho
#incluirSintaxe
inttubo(intfiledes[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, teremos uma ideia.
// Exemplo1.c#incluir
#incluir
#incluir
#incluir
inta Principal()
{
intn;
intfiledes[2];
Caracteresamortecedor[10: 25h];
Caracteres *mensagem= 'Olá Mundo!';
tubo(filedes);
escrever(filedes[1],mensagem, Strlen (mensagem));
E se ((n=leitura(filedes[0],amortecedor, 1024 ) ) > = 0) {
amortecedor[n] = 0; // termina a string
printf ('ler% d bytes do tubo:'%s' n',n,amortecedor);
}
outro
perror ('leitura');
saída (0);
}
Aqui, primeiro criamos um tubo usando tubo() função, em seguida, escrito para o tubo usando marfim [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 escrever() funções.
Exemplo 2
Neste exemplo, veremos como os processos pai e filho se comunicam usando o pipe.
// Exemplo2.c#incluir
#incluir
#incluir
#incluir
#incluir
inta Principal()
{
intfiledes[2],nbytes;
pid_t childpid;
Caracteresfragmento[] = 'Olá Mundo! n';
Caracteresreadbuffer[80];
tubo(filedes);
E se((childpid=garfo()) == -1)
{
perror ('garfo');
saída (1);
}
E se(childpid== 0)
{
fechar(filedes[0]);// O processo filho não precisa dessa extremidade do tubo
/ * Enviar 'string' através do lado de saída do tubo * /
escrever(filedes[1],fragmento, ( Strlen (fragmento)+1));
saída (0);
}
outro
{
/ * O processo pai fecha o lado de saída do tubo * /
fechar(filedes[1]);// O processo pai não precisa dessa extremidade do tubo
/ * Leia em uma string a partir do tubo * /
nbytes=leitura(filedes[0],readbuffer, tamanho de(readbuffer));
printf ('Ler string:% s',readbuffer);
}
Retorna(0);
}
Primeiro, um canal foi criado usando a função de canal e, em seguida, um processo filho foi bifurcado. Em seguida, o processo filho fecha a extremidade de leitura e grava no canal. O processo pai fecha a extremidade de gravação, lê o tubo e o exibe. Aqui, o fluxo de dados é apenas uma forma 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 onde também podemos alcançar o fluxo de dados bidirecional.