Em sistemas semelhantes a UNIX, os tubos são um mecanismo para a comunicação entre processos (IPC). Eles permitem um processo para enviar dados para outro processo. Existem dois tipos principais:Pipes nomeados (também chamados FIFOs) e tubos sem nome (também chamados de tubos anônimos).
tubos sem nome (tubos anônimos): *
Criação: Criado usando a chamada do sistema `Pipe ()`. Esta chamada cria um tubo unidirecional composto por dois descritores de arquivos:um para leitura (`fd [0]`) e outro para escrever (`fd [1]`).
*
Acesso: Somente o processo que criou o tubo pode acessá -lo. A existência do tubo não é conhecida fora do contexto do processo de criação. Normalmente usado para comunicação entre um processo pai e filho ou entre dois processos que estão explicitamente conectados.
*
Lifetime: O tubo existe apenas para a vida útil dos processos que o utiliza. Quando um dos processos fecha o fim, o tubo é destruído automaticamente e quaisquer outras tentativas de ler ou escrever falharão.
*
Exemplo (usando `fork ()` e `Pipe ()`): `` `c
#include
#include
#include
#include
int main () {
int fd [2]; // Descritores de arquivo para o tubo
pid_t pid;
if (tubo (fd) ==-1) {
perror ("falha no tubo");
saída (1);
}
pid =fork ();
if (pid <0) {
Perror ("Fork falhou");
saída (1);
} else if (pid ==0) {// Processo infantil
fechar (FD [1]); // Fechar o fim da gravação
buffer de char [100];
Leia (FD [0], buffer, sizeof (buffer));
printf ("criança recebida:%s \ n", buffer);
fechar (fd [0]);
} else {// processo pai
fechar (fd [0]); // Feche o final de leitura
const char* message ="Olá do pai!";
write (fd [1], mensagem, strlen (mensagem) + 1); // +1 para terminador nulo
fechar (FD [1]);
espere (nulo); // Aguarde a criança terminar
}
retornar 0;
}
`` `
Nomeado tubos (FIFOs):
* Criação: Criado usando a chamada `mkfifo ()` sistema. Isso cria um arquivo no sistema de arquivos que representa o tubo. O nome do arquivo atua como o identificador do tubo.
* Acesso: Vários processos podem acessar um tubo nomeado. Qualquer processo que saiba que o caminho do tubo pode abri -lo para leitura ou escrita (embora apenas um processo possa escrever por vez, a menos que use configurações especiais). Eles sobrevivem além da vida útil dos processos que os usam.
* Lifetime: O tubo persiste no sistema de arquivos até ser excluído explicitamente usando `desvincular ()`.
* Exemplo (usando dois programas separados se comunicando através de um tubo nomeado):
Você precisaria de dois programas:um para escrever para o FIFO e outro para ler. `mkfifo ()` é chamado uma vez (talvez em um script de configuração) para criar o FIFO, então os programas `open ()` o FIFO para leitura/gravação. Os processos precisam lidar com erros, incluindo a possibilidade de o FIFO não existir e erros em `open ()`.
As diferenças de chave resumidas:
| Recurso | Tubo sem nome | Nomeado Pipe (FIFO) |
| ---------------------- | -------------------------- | ------------------------------- |
| Criação | `Pipe ()` | `mkfifo ()` |
| Acesso | Apenas criando processo | Vários processos |
| Persistência | Existe apenas durante a vida útil do processo | Persiste no sistema de arquivos |
| Interprocesso | Normalmente, processos entre pais ou crianças ou explicitamente conectados | Pode conectar processos não relacionados |
| Entrada do sistema de arquivos | Não | Sim |
Os tubos nomeados são mais flexíveis para a comunicação entre processos não relacionados, enquanto os tubos sem nome são mais simples e mais eficientes para a comunicação entre processos intimamente relacionados, como um pai e seu filho. A escolha depende das necessidades de comunicação específicas do seu aplicativo.
