2.15 Introduction et utilisation de tubes célèbres

table des matières

1. Un aperçu des pipelines bien connus

2. Créez un fichier fifo

3. Les deux processus communiquent par un canal bien connu

---

1. Un aperçu des pipelines bien connus

2. Créez un fichier fifo

Méthode 1: via la commande: nom mkfifo

Méthode 2: grâce à la fonction mkfifo

1.通过命令： mkfifo 名字
2.通过函数： int mkfifo(const char *pathname, mode_t mode);


#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);
    参数：
        -pathname：管道名称的路径
        -mode：文件的权限，和open的mode是一样的，是一个八进制的数
    返回值：成功返回0，失败返回-1，并设置errno
        

 Exemple de programme:

#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{

    //判断管道文件fifo1是否存在
    int ret = access("fifo1", F_OK);
    if (ret == -1)
    {
        printf("fifo1不存在，创建fifo1\n");
        ret = mkfifo("fifo1", 0664);
        if (ret == -1)
        {
            perror("mkfifo");
            return -1;
        }
    }

    return 0;
}

résultat de l'opération:

---

3. Les deux processus communiquent par un canal bien connu

Fichier write.c:

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

int main()
{

    //判断管道文件fifo1是否存在
    int ret = access("fifo1", F_OK);
    //如果不存在，创建管道文件
    if (ret == -1)
    {
        printf("fifo1不存在，创建fifo1\n");
        ret = mkfifo("fifo1", 0664);
        if (ret == -1)
        {
            perror("mkfifo");
            return -1;
        }
    }
    //以只写方式打开管道文件
    int fd=open("fifo1",O_WRONLY);
    if(fd==-1)
    {
        perror("open");
        return -1;
    }


    //往管道中写数据
    char buf[1024]={0};
    for(int i=0;i<100;i++)
    {
        sprintf(buf,"hello:%d\n",i);
        printf("write:%s\n",buf);
        write(fd,buf,strlen(buf));
        bzero(buf,1024);
        sleep(1);
    }


    close(fd);

    return 0;
}

Fichier read.c:

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

int main()
{
    //以只读方式打开管道
    int fd=open("fifo1",O_RDONLY);
    if(fd==-1)
    {
        perror("open");
        return -1;
    }
    //从管道中读数据
    char buf[1024]={0};
    while(1)
    {
        int len=read(fd,buf,sizeof(buf));
        if(len==0)
        {
            printf("写端断开连接\n");
            break;
        }
        else if(len>0)
        {
            printf("read recv:%s\n",buf);
            bzero(buf,1024);
            /* code */
        }
        
    }
    return 0;
}

Exécuter les résultats: (dans deux terminaux)

---

Remarque sur les célèbres pipes:

1. Une fois qu'un processus ouvre l'extrémité en lecture seule du tube, il se bloque jusqu'à ce qu'un autre processus ouvre l'extrémité en écriture seule du tube

2. Une fois qu'un processus ouvre l'extrémité en écriture seule du tube, il se bloque jusqu'à ce qu'un autre processus ouvre l'extrémité en lecture seule du tube

Lire le pipeline:

  Il y a des données dans le pipeline: read renvoie le nombre d'octets réellement lus

  Aucune donnée dans le pipeline:

         Si toutes les extrémités d'écriture du tube sont fermées, read renvoie 0 (équivalent à la lecture jusqu'à la fin du fichier)

        Si la fin de l'écriture n'est pas fermée, lisez le bloc et attendez

 

Écrire le pipeline:

    Toutes les extrémités de lecture de tube sont fermées: le processus se termine anormalement (a reçu un signal SIGPIPE)

    L'extrémité de lecture du tuyau n'est pas entièrement fermée:

             Le pipeline est plein, l'écriture bloquera

             Le pipeline n'est pas plein, write écrit les données et renvoie le nombre d'octets réellement écrits