Home > Article > System Tutorial > Linux Named Pipes (FIFO): A simple yet powerful way to communicate between processes
Linux Named Pipes (FIFO): A simple yet powerful way to communicate between processes
- WBOYforward
- 2024-02-11 21:36:18798browse
Linux system is an operating system that supports concurrent execution of multi-tasks. It can run multiple processes at the same time, thereby improving system utilization and efficiency. However, if data exchange and collaboration are required between these processes, some inter-process communication (IPC) methods need to be used, such as signals, message queues, shared memory, semaphores, etc. Among them, the famous pipe (FIFO) is a relatively simple and powerful IPC method. It allows two or more processes to transmit data through a file without caring about the content and format of the file. This article will introduce the blocking and non-blocking reading and writing methods of famous pipes (FIFO) in Linux systems, including the creation, opening, reading, writing, closing and deletion of famous pipes.
//Writing process
#include
#include
#include
#include
#include
#include
#define FIFO_NAME “/tmp/myfifo”
main()
{
int fd;
char w_buf[50];
int w_num;
// If fifo already exists, use it directly, otherwise create it
if((mkfifo(FIFO_NAME,0777)
{
printf(“cannot create fifo…\n”);
exit(1);
}
//Open fifo in blocking write-only mode
fd=open(FIFO_NAME,O_WRONLY);
w_num=write(fd,”abcdg\0″,6);
printf(“%d\n”,w_num);
}
//Reading process
#include
#include
#include
#include
#define FIFO_NAME “/tmp/myfifo”
main()
{
char r_buf[50];
int fd;
int r_num;
// If fifo already exists, use it directly, otherwise create it
if((mkfifo(FIFO_NAME,0777)
{
printf(“cannot create fifo…\n”);
exit(1);
}
//Open fifo in blocking read-only mode
fd=open(FIFO_NAME,O_RDONLY);
if(fd==-1)
{
printf(“open %s for read error\n”);
exit(1);
}
// Enter a string through the keyboard, and then write it to the fifo until "exit" is entered
r_num=read(fd,r_buf,6);
printf(” %d bytes read:%s\n”,r_num,r_buf);
unlink(FIFO_NAME);//Delete fifo
}
1. The writing process is blocked and the reading process is blocked.
Run the writing process first (blocked), then run the reading process, everything is normal.
Run the reading process first (blocked), then run the writing process, everything is normal.
2. The writing process is blocked and the reading process is non-blocking.
Just change the code fd=open(FIFO_NAME,O_RDONLY | O_NONBLOCK), similar to the following.
Run the writing process first (blocked), then run the reading process, everything is normal.
Run the reading process first, and the program crashes directly (Segmentation fault (core dumped)). It is quite natural when you think about it. You have nothing to read and you don’t want to wait.
3. The writing process is non-blocking and the reading process is blocking.
Run the writing process first, the open call will return -1, and the open fails.
Run the reading process first (blocked), then run the writing process, everything is normal.
4. The writing process is non-blocking and the reading process is non-blocking.
In fact, it is an abnormal situation where half of each of the above 2 and 3 categories are taken.
Also, we can see through the ls -la command in the /tmp directory that the size of the pipe file myfifo is always 0. This is because although the FIFO file exists in the file system, the contents of the FIFO are stored in memory. , so the file size is always 0.
This article introduces the blocking and non-blocking reading and writing methods of famous pipes (FIFO) in Linux systems, including the creation, opening, reading, writing, closing and deletion of famous pipes. By understanding and mastering this knowledge, we can better use famous pipes (FIFO) to implement inter-process communication and improve system performance and reliability. Of course, there are many other features and usages of famous pipes (FIFO) in Linux systems, which require us to continue to learn and explore. I hope this article can bring you some inspiration and help.
The above is the detailed content of Linux Named Pipes (FIFO): A simple yet powerful way to communicate between processes. For more information, please follow other related articles on the PHP Chinese website!