Le système Linux est un système d'exploitation qui prend en charge l'exécution simultanée de tâches multiples. Il peut exécuter plusieurs processus en même temps, améliorant ainsi l'utilisation et l'efficacité du système. Cependant, si l'échange de données et la collaboration sont requis entre ces processus, certaines méthodes de communication inter-processus (IPC) doivent être utilisées, telles que les signaux, les files d'attente de messages, la mémoire partagée, les sémaphores, etc. Parmi eux, le fameux pipe (FIFO) est une méthode IPC relativement simple et puissante. Elle permet à deux ou plusieurs processus de transmettre des données via un fichier sans se soucier du contenu et du format du fichier. Cet article présentera la méthode des canaux nommés (FIFO) dans les systèmes Linux, y compris la création, l'ouverture, la lecture, l'écriture, la fermeture et la suppression de canaux célèbres.
Une limitation majeure de l'application des canaux sans nom est qu'ils n'ont pas de nom, ils ne peuvent donc être utilisés que pour la communication inter-processus avec affinité. Cette limitation a été surmontée après l'introduction des canaux nommés (tubes nommés ou FIFO). FIFO est différent d'un tube dans la mesure où il fournit un nom de chemin qui lui est associé, qui existe dans le système de fichiers sous la forme d'un fichier FIFO. De cette manière, même s'il n'y a aucune affinité avec le processus qui crée le chemin FIFO, tant que le chemin est accessible, ils peuvent communiquer entre eux via le FIFO (entre le processus qui peut accéder au chemin et le processus qui a créé le FIFO). Par conséquent, il n’y a pas de corrélation via le FIFO. Les processus peuvent également échanger des données. Il convient de noter que FIFO suit strictement le premier entré, premier sorti (premier entré, premier sorti). La lecture à partir des tubes et FIFO renvoie toujours les données depuis le début, et l'écriture dans ceux-ci ajoute des données à la fin. Ils ne prennent pas en charge les opérations de localisation de fichiers telles que lseek().
Le buffer d'un tube est limité (le mécanisme du tube existe en mémoire, et une taille de page est allouée au buffer lors de la création du tube)
Ce que le pipeline transmet est un flux d'octets non formaté, ce qui nécessite que le lecteur et l'écrivain du pipeline se mettent d'accord à l'avance sur le format des données, comme le nombre d'octets comptés comme message (ou commande, ou enregistrement), etc.
FIFO a souvent plusieurs processus d'écriture et un seul processus de lecture.
Règles d'ouverture du FIFO :
-
Si l'opération d'ouverture en cours consiste à ouvrir le FIFO en lecture, si un processus correspondant a déjà ouvert le FIFO en écriture, l'opération d'ouverture en cours reviendra avec succès, sinon elle peut être bloquée jusqu'à ce qu'un processus correspondant ouvre le FIFO en écriture (le ; opération d'ouverture actuelle L'indicateur de blocage est défini ; ou, renvoie avec succès (l'opération d'ouverture actuelle n'a pas l'indicateur de blocage défini).
-
Si l'opération d'ouverture en cours consiste à ouvrir le FIFO pour l'écriture, si un processus correspondant a déjà ouvert le FIFO pour la lecture, l'opération d'ouverture en cours reviendra avec succès, sinon elle peut être bloquée jusqu'à ce qu'un processus correspondant ouvre le FIFO pour la lecture (le opération d'ouverture en cours L'indicateur de blocage est activé ; ou une erreur ENXIO est renvoyée (l'indicateur de blocage n'est pas activé pour l'opération d'ouverture en cours).
En bref, en une phrase, une fois le drapeau de blocage défini et mkfifo appelé pour l'établir, la lecture et l'écriture aux deux extrémités du tube doivent être ouvertes séparément. Si l'un des côtés n'est pas ouvert, il sera bloqué lorsque. open est appelé.
Lire les données du FIFO :
Convention : Si un processus bloque l'ouverture du FIFO afin de lire les données du FIFO, alors l'opération de lecture au sein du processus est appelée une opération de lecture avec l'indicateur de blocage défini. (Ça veut dire que je veux maintenant ouvrir un fameux tube pour lire des données !)
Si un processus écrit pour ouvrir le FIFO et qu'il n'y a actuellement aucune donnée dans le FIFO (on peut comprendre que les deux extrémités du canal ont été établies, mais que la fin de l'écriture n'a pas encore commencé à écrire des données !)
-
Ensuite, pour l'opération de lecture avec l'indicateur de blocage défini, elle sera toujours bloquée (c'est-à-dire bloquée et en attente de données. Elle ne consomme pas de ressources CPU. Cette méthode de synchronisation des processus est très efficace pour le CPU.)
-
Pour les opérations de lecture sans définir l'indicateur de blocage, -1 est renvoyé et la valeur actuelle du numéro d'erreur est EAGAIN, vous rappelant de réessayer plus tard.
Pour les opérations de lecture avec le drapeau de blocage défini (voir la convention ci-dessus)
Il y a deux raisons d'obstruction
-
FIFO内有数据，但有其它进程在读这些数据
-
FIFO内没有数据。解阻塞的原因则是FIFO中有新的数据写入，不论信写入数据量的大小，也不论读操作请求多少数据量。
读打开的阻塞标志只对本进程第一个读操作施加作用，如果本进程内有多个读操作序列，则在第一个读操作被唤醒并完成读操作后，其它将要执行的读操作将不再阻塞，即使在执行读操作时，FIFO中没有数据也一样,此时，读操作返回0。
注：如果FIFO中有数据，则设置了阻塞标志的读操作不会因为FIFO中的字节数小于请求读的字节数而阻塞，此时，读操作会返回FIFO中现有的数据量。
向FIFO中写入数据：
约定：如果一个进程为了向FIFO中写入数据而阻塞打开FIFO，那么称该进程内的写操作为设置了阻塞标志的写操作。
对于设置了阻塞标志的写操作：
-
当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数，则进入睡眠，直到当缓冲区中能够容纳要写入的字节数时，才开始进行一次性写操作。（PIPE_BUF ==>> /usr/include/linux/limits.h）
-
当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域，写进程就会试图向管道写入数据，写操作在写完所有请求写的数据后返回。
对于没有设置阻塞标志的写操作：
-
当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后，写操作返回。
-
当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数，写完后成功返回；如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数，则返回EAGAIN错误，提醒以后再写；
简单描述下上面设置了阻塞标志的逻辑
设置了阻塞标志
if (buf_to_write then
if ( buf_to_write > system_buf_left ) //保证写入的原子性,要么一次性把buf_to_write全都写完，要么一个字节都不写！
then
block ;
until ( buf_to_write else
write ;
fi
else
write ; //不管怎样，就是不断写，知道把缓冲区写满了才阻塞
fi
Copier après la connexion
管道写端 pipe_read.c
/pipe_read.c
#include
#include
#include
#include
#include
#include
#include
#define FIFO_NAME "/tmp/my_fifo"
#define BUFFER_SIZE PIPE_BUF
int main()
{
int pipe_fd;
int res;
int open_mode = O_RDONLY;
char buffer[BUFFER_SIZE + 1];
int bytes = 0;
memset(buffer, '\0', sizeof(buffer));
printf("Process %d opeining FIFO O_RDONLY\n", getpid());
pipe_fd = open(FIFO_NAME, open_mode);
printf("Process %d result %d\n", getpid(), pipe_fd);
if (pipe_fd != -1)
{
do{
res = read(pipe_fd, buffer, BUFFER_SIZE);
bytes += res;
printf("%d\n",bytes);
}while(res > 0);
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf("Process %d finished, %d bytes read\n", getpid(), bytes);
exit(EXIT_SUCCESS);
}
Copier après la connexion
管道读端 pipe_write.c
//pipe_write.c
#include
#include
#include
#include
#include
#include
#include
#define FIFO_NAME "/tmp/my_fifo"
#define BUFFER_SIZE PIPE_BUF
#define TEN_MEG (1024 * 100)
int main()
{
int pipe_fd;
int res;
int open_mode = O_WRONLY;
int bytes = 0;
char buffer[BUFFER_SIZE + 1];
if (access(FIFO_NAME, F_OK) == -1)
{
res = mkfifo(FIFO_NAME, 0777);
if (res != 0)
{
fprintf(stderr, "Could not create fifo %s\n", FIFO_NAME);
exit(EXIT_FAILURE);
}
}
printf("Process %d opening FIFO O_WRONLY\n", getpid());
pipe_fd = open(FIFO_NAME, open_mode);
printf("Process %d result %d\n", getpid(), pipe_fd);
//sleep(20);
if (pipe_fd != -1)
{
while (bytes if (res == -1)
{
fprintf(stderr, "Write error on pipe\n");
exit(EXIT_FAILURE);
}
bytes += res;
printf("%d\n",bytes);
}
close(pipe_fd);
}
else
{
exit(EXIT_FAILURE);
}
printf("Process %d finish\n", getpid());
exit(EXIT_SUCCESS);
}
Copier après la connexion
本文介绍了Tubes nommés (FIFO) dans les systèmes Linux的方法，包括有名管道的创建、打开、读写、关闭和删除等方面。通过了解和掌握这些知识，我们可以更好地使用有名管道（FIFO）来实现进程间通信，提高系统的性能和可靠性。当然，Tubes nommés (FIFO) dans les systèmes Linux还有很多其他的特性和用法，需要我们不断地学习和探索。希望本文能给你带来一些启发和帮助。
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
