Ir para o conteúdo

Última atualização：2026-10-12

Comunicação entre processos em C++ na prática

Comunicação entre processos é um tema muito importante, especialmente em grandes projetos onde sua presença é constante: por exemplo, o PostgreSQL usa pipes para a comunicação entre processos do copy. Nesta seção, também a partir desse tema, construiremos com C++ uma demo de comunicação entre processos via pipe, combinando o conteúdo das seções anteriores para entregar um exemplo prático bem completo:

  • mutex
  • condition_variable
  • thread

Nota: o código completo desta seção será disponibilizado na planeta.

Primeiro, um uso bem simples de pipe:

  • Criar um pipe

Ele faz creating a pipe, forking, and invoking the shell.

// FILE *popen(const char *command, const char *type);
pipe = popen(command.c_str(), "w");
- Fechar um pipe

// int pclose(FILE *stream);
pclose(pipe);
Em seguida, só precisamos escrever e ler nele; o princípio também é simples, por exemplo:

Assim, data é escrita no pipe criado anteriormente.

// size_t fwrite( const void* buffer, size_t size, size_t count, FILE* stream );
size_t written = fwrite(data.c_str(), sizeof(char), data.size(), pipe);
Para ler do pipe, podemos usar fread ou fgets: fgets para ao encontrar um caractere de nova linha ou ao atingir o tamanho do buffer, enquanto fread lê o máximo de dados possível, até atingir o número de bytes especificado ou chegar ao fim do arquivo. Pela mesma lógica, o fwrite acima pode ser substituído por fputs.

Agora que o uso básico do pipe foi apresentado, como escrever uma demo completa?

Simples: basta criar duas threads, uma para ler e outra para escrever; a thread de escrita grava dados no pipe e a thread de leitura lê do pipe.

Por exemplo:

std::thread writer_thread(write_to_pipe);
std::thread reader_thread(read_from_pipe);

writer_thread.join();
reader_thread.join();
O que a thread de escrita precisa fazer é apenas chamar fwrite para despejar os dados

ProcessWriter writer("cat > /tmp/pipe");

// 写入数据
std::string message = "Hello pipe!\n";
if (!writer.write(message)) {
  std::cerr << "Failed to write data to pipe" << std::endl;
}
Pela mesma lógica, a thread de leitura recupera os dados:

ProcessReader reader("/tmp/pipe");
// 读取数据
std::string message;
while (reader.read(message)) {
  // do something
}
O resultado final é:

Read from pipe: Hello pipe!

Tópicos relacionados

Comentários