Why is fopen blocked when server has a running thread? - multithreading

Question

when a server fopen a pipe for read and starts a thread by std::async, for the first time, the client can fopen the pipe for write, but if the client writes again, the client is blocked until the thread ends, the server can fopen to read the pipe.
Any idea?
Kai

Answer 1

Apologizing for my confusing description. Here are snippets of code.
Server side:
#define FIFO_FILE "/tmp/fifo"
while (1)
{
char readbuf[25];
FILE *file = fopen(FIFO_FILE, "r");
fgets(readbuf, 25, file);
std::queue<std::string>().swap(msg);
msg.push(readbuf);
while (!feof(file))
{
fgets(readbuf, 25, file);
msg.push(readbuf);
}
std::cout << "message num: " << msg.size() << std::endl;
std::future<void> ret = std::async (std::launch::async, command_process, std::ref(msg), std::ref(binfo));
fclose(file);
std::cout << "messages are being processed!\n";
}
client side:
int main(int argc, char *argv[])
{
FILE *fp;
if((fp = fopen(FIFO_FILE, "w")) == NULL) {
perror("fopen \n");
return -1;
}
fputs(argv[1], fp);
fclose(fp);
return 0;
}
After the server starts, it waits at fgets. When the client sends a string to FIFO, the server receives the string and store it in msg,
then pass it to thread command_process for processing, the server waits
at fopen for further message. HOWEVER if the client tries to send message again, it would be blocked at the client's fopen until the server's thread finishes processing, the server continues to receive the client's message.
I expect the client should not be blocked to send out message and the server should receive the message immediately, then abort the previous message to process new message.
Kai