我的 C++ 程序如何才能等到对命名的 pipe 进行新的写入？

Question

I have two separate programs in C++, one that writes to two named pipes in unpredictable intervals and one that should wait to read new content from the pipes whenever available. For simplicity, here my writer only writes two times to the pipes (1st: "One" "Tree", 2nd: "Two" "Fogs").

My writer program is:

#include <unistd.h>
#include <iostream>

int main()
{
    int fd1, fd2;
    const char* myfifo1 = "/tmp/myfifo1";
    const char* myfifo2 = "/tmp/myfifo2";

    mkfifo(myfifo1, 0666);
    mkfifo(myfifo2, 0666);

    fd1 = open(myfifo1, O_WRONLY);
    fd2 = open(myfifo2, O_WRONLY);

    write(fd1, "One", sizeof("One"));
    write(fd2, "Tree", sizeof("Tree"));

    sleep(5);

    write(fd1, "Two", sizeof("Two"));
    write(fd2, "Fogs", sizeof("Fogs"));

    close(fd1);
    close(fd2);

    unlink(myfifo1);
    unlink(myfifo2);
}   

My reader program is:

#include <fcntl.h>
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>

#define MAX_BUF 1024

int main()
{
    int fd1, fd2;
    const char * myfifo1 = "/tmp/myfifo1";
    const char * myfifo2 = "/tmp/myfifo2";
    char buf1[MAX_BUF], buf2[MAX_BUF];
    
    fd1 = open(myfifo1, O_RDONLY);
    fd2 = open(myfifo2, O_RDONLY);
    
    while (1) {
        read(fd1, buf1, MAX_BUF);
        read(fd2, buf2, MAX_BUF);
        
        printf("Received: %s\n", buf1);
        printf("Received: %s\n", buf2);
    }

    close(fd1);
    close(fd2);
    return 0;
}

I do not want the reader to terminate or close the connection between the reads, I need it to remain active and wait until the writer writes something new in the named pipe. However, by simultaneously running these two programs (in different cores, first the writer and then the reader) I get:

Received: One
Received: Tree
Received: Two
Received: Fogs
Received: Two
Received: Fogs
Received: Two
Received: Fogs
Received: Two
Received: Fogs
      ...
      ...

The wanted behavior would be:

Received: One
Received: Tree
Received: Two
Received: Fogs

and then nothing (the reader should wait for another write).

I understand that I should somehow clear the buffer after I read it, but isn't it the default behavior of read? Since it finished reading "Two" (and also "Fogs"), why does it keep reading it and does not wait for new content?

What modifications should I make?

Thank you very much in advance!

Answer 1

Closing a pipe signals end-of-file to the other end.

read will read zero bytes (and return zero) whenever it encounters an end-of-file condition. Any subsequent read after the end-of-file is a no-op.

If you want to continue reading from the same pipe, you need to check the result of read , and if it returns zero, close the pipe and open it again.

Of course you should not unlink the pipe if you need someone else to continue using it.

One other thing to note: read (1) doesn't terminate the buffer with the 0 byte and (2) doesn't necessarily read the exact amount of bytes that was written by a single write . You should detect the end-of-message yourself, rather than relying on read and write to do it for you. It is entirely possible that read will read a half of the string without the terminating null character, then your printf will print garbage.