Linux多进程编程三——进程通信其一

一、进程通信基础

1.什么是进程通信

　　进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。但是，进程不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信( IPC：Inter Processes Communication )。

　　进程间通信的目的：

　　1.数据传输：一个进程需要将它的数据发送给另一个进程

　　2.通知事件：一个进程需要向另一个或一组进程发送消息，通知其发生了某件事（如子进程终止需要通知父进程）

　　3.资源共享：多个进程之间共享同样的资源。

　　4.进程控制：有些进程希望完全控制另一个进程的运行（如DEBUG），此时控制进程希望能够拦截另一个进程的所有陷入和异常。

2.进程间通信方式分类

二、管道通信

1.匿名管道通信

1.概念

　　管道也叫无名（匿名）管道，它是是 UNIX 系统 IPC（进程间通信）的最古老形式，所有的 UNIX 系统都支持这种通信机制。统计一个目录中文件的数目命令：ls | wc –l，为了执行该命令，shell 创建了两个进程来分别执行 ls 和 wc。

2.（匿名）管道特点

　　1.管道其实是一个在内核内存中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的操作系统大小不一定相同。

　　2.管道拥有文件的特质：读操作、写操作，匿名管道没有文件实体，有名管道有文件实体，但不存储数据。可以按照操作文件的方式对管道进行操作。

　　3.一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读取数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。

　　4.通过管道传递的数据是顺序的，从管道中读取出来的字节的顺序和它们被写入管道的顺序是完全一样的。

　　5.在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的。

　　6.从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据，在管道中无法使用 lseek() 来随机的访问数据。

　　7.匿名管道只能在具有公共祖先的进程（父进程与子进程，或者两个兄弟进程，具有亲缘关系）之间使用。

　　8.管道的数据结构是逻辑上的环形队列，由读指针和写指针操作

3.匿名管道相关指令和匿名管道创建

ulimit -a//查看管道缓冲区大小命令
long fpathconf(int fd, int name); //查看管道缓冲大小函数
//name为可选宏参数
_PC_PIPE_BUF //为查看缓冲大小

　　这里缓冲区大小为8块512字节，一共4096字节。

　　创建匿名管道

/*

        #include <unistd.h>
        int pipe(int pipefd[2]);
        作用：创建一个匿名管道用作进程间的通信，
        参数：
            int pipefd[]数组为传出参数（即函数存），存放两个文件描述符
                pipefd[0]对应管道读端
                pipefd[1]对应管道写端
        返回值：
            -成功：0
            -失败：-1
        #########匿名管道只能在有亲缘关系的进程中通信
        #########管道默认是阻塞的，若管道无数据，read阻塞，若管道已满，write阻塞
*/

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

//子进程发送数据给父进程，父进程读取到数据进行输出
int main(){
    //在父子进程创建之前创建管道
    int pipefd[2];
    int pipefd1[2];
    int ret = pipe(pipefd);
    int ret1 = pipe(pipefd1);
    if(ret==-1||ret1==-1){
        perror("pipe");
        exit(0);
    }
    pid_t pid;
    pid = fork();
    //父进程
    if(pid>0){
        printf("i am parent pid:%d\n", getpid());
        char buf[1024] = {0};
        while(1){
            //父进程管道1读取，管道2写入
            int len = read(pipefd[0], buf, sizeof(buf));
            printf("parent recive : %s, pid:%d\n", buf, getpid());
            
            char * str = "hello, i am parent";
            write(pipefd1[1], str, strlen(str));
            sleep(1);
        }
    }
    //子进程
    else if(pid==0){
        printf("i am child pid:%d\n", getpid());
        char buf[1024] = {0};
        while(1){
            //子进程管道1写入，管道2读取
            char * str = "hello, i am child";
            write(pipefd[1], str, strlen(str));
            sleep(1);
            int len = read(pipefd1[0], buf, sizeof(buf));
            printf("child recive : %s, pid:%d\n", buf, getpid());
        }
        
    }
    return 0;

}

4.匿名管道读写特点

使用管道时，需注意（假设都是在I/O阻塞操作）　　

　　1.所有的写端都关闭了（管道写端引用计数为0），有进程从管道的读端读数据，那么管道中剩余的数据被读取后，再次读取就会返回0，就像已经读到了末尾一样

　　2.如果写端没有全关闭（管道写端引用计数大于0），而持有管道写端的进程没有向管道中写数据，这时候有进程从管道中读取数据，此时会阻塞，直到写端写入数据

　　3.如果读端都关闭了（管道读端引用计数为0），此时有进程向管道写数据，那么该进程会收到信号SIGPIPE，通常会导致进程异常终止

　　4.如果读端没有全关闭（管道读端引用计数大于0），此时写入数据会阻塞，直到读端读取数据

总结：
读：
管道中有数据：read实际读到的
管道中无数据：
　　写端全部关闭，read返回0
　　写端有未关闭，read阻塞等待
写：
管道读端全关闭，进程会异常终止（进程受到SIGPIPE信号）
管道读端没有全部关闭：
　　管道已满，阻塞
　　管道未满，进行写入

2.有名管道通信

　　有名管道(FIFO)与匿名管道大部分特点一致，除了：

　　1.FIFO在文件系统中作为一个特殊文件存在，但 FIFO中的内容却存放在内存中。

　　2.当使用FIFo的进程退出后，FIFO文件将继续保存在文件系统中以便以后使用。

　　3.FIFO有名字，不相关的进程可以通过打开有名管道进行通信。

2.1 有名管道的创建

　　创建有名管道文件fifo：

　　1.通过命令mkfifo name

　　2.通过函数int mkfifo(const char *pathname, mode_t mode);

/*
    创建有名管道文件fifo：
    1.通过命令mkfifo name
    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，设定管道文件的权限（,8进制，注意与掩码反码按位与）
            -返回值：
                成功：0
                失败：-1
*/
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include<stdio.h>
#include<string.h>

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

2.2 有名管道的通信

　有名管道注意事项：

1、一个为只读而打开一个管道的进程会阻塞，直到另一个进程为只写打开管道

2、一个为只写而打开一个管道的进程会阻塞，直到另一个进程为只读打开管道

读管道：

1、有数据返回实际读到的数据

2、无数据：

-写端全部关闭：返回0，相当于读到文件末尾

-写端没有全部关闭：阻塞

写管道：

1、读端被全部关闭，进程会异常终止(sigpipe信号)

2、读端没有全部关闭：

管道已满：会阻塞

管道没有满：写入数据并返回实际写入字节数

/*
    向有名管道写数据
*/
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include<stdio.h>
#include <fcntl.h>
#include<string.h>

//向管道中写数据

int main(){
    //判断文件是否存在
    int ret1 = access("fifo1",F_OK);
    if(ret1==-1){
        printf("文件不存在，创建");
        //创建管道文件
        int ret = mkfifo("fifo1", 0664);
        if(ret == -1){
            perror("mkfifo");
            exit(0);
        }
    }
    //以只写方式打开管道
    int fd = open("fifo1", O_WRONLY);
    if(fd==-1){
        perror("open");
        exit(0);
    }
    
    for(int i =0;i<100;++i){
        char buf[1024];
        sprintf(buf,"hello: %d\n", i);
        printf("write date: %s\n", buf);
        write(fd, buf, strlen(buf));
        sleep(1);
    }
    close(fd);

    return 0;
}

/*
    从有名管道读数据

*/

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

//从管道中读数据
int main(){
    //1.打开管道文件
    int fd = open("fifo1", O_RDONLY);
    if(fd ==-1){
        perror("open");
        exit(0);
    }
    //2.读数据
    while(1){
        char buf[1024] = {0};
        int len = read(fd, buf, sizeof(buf));
        //如果写端已经关闭
        if(len==0){
            printf("写端断开连接了.....\n");
            break;
        }
        printf("recv buf: %s\n", buf);
    }
    //3.关闭文件描述符
    close(fd);
    return 0;
}

2.3 使用有名管道完成简单的进程间聊天

　　　功能为进程A和进程B之间依次交替发送和接收，不连续发送和接收（利用两根管道），流程如下：

代码：

进程A ：

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

//进程A
int main(){
    //1.判断有名管道文件是否存在（管道1）
    int ret = access("fifo1",F_OK);
    if(ret==-1){
        printf("管道不存在，创建对应管道\n");
        ret = mkfifo("fifo1", 0664);
        if(ret == -1){
            perror("mkfifo");
            exit(0);
        }
    }
    //2.判断有名管道文件是否存在（管道2）
    ret = access("fifo2",F_OK);
    if(ret==-1){
        printf("管道不存在，创建对应管道\n");
        ret = mkfifo("fifo2", 0664);
        if(ret == -1){
            perror("mkfifo");
            exit(0);
        }
    }
    //3.以只写的方式打开管道1
    int fdw = open("fifo1", O_WRONLY);
    if(fdw==-1){
        perror("open");
        exit(0);
    }
    printf("打开FIFO1成功，等待写入数据\n");
    //4.以只读的方式打开管道2
    int fdr = open("fifo1", O_RDONLY);
    if(fdr==-1){
        perror("open");
        exit(0);
    }
    printf("打开fifo2成功，等待读取数据\n");
    char buf[128];
    //4.循环写读数据
    while(1){
        //获取标准输入
        memset(buf, 0, 128);
        fgets(buf, 128, stdin);
        //写数据
        ret = write(fdw, buf ,strlen(buf));
        if(ret == -1){
            perror("write");
            exit(0);
        }
        //等待读取管道2数据
        memset(buf, 0, 128);
        ret = read(fdr, buf, 128);
        //如果没有可读取数据
        if(ret<=0){
            perror("read:");
            break;
        }
        printf("get: %s\n", buf);

    }
    //关闭文件描述符
    close(fdw);
    close(fdr);

    return 0;
}

进程B：

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

//进程B
int main(){
    //1.判断有名管道文件是否存在（管道1）
    int ret = access("fifo1",F_OK);
    if(ret==-1){
        printf("管道不存在，创建对应管道\n");
        ret = mkfifo("fifo1", 0664);
        if(ret == -1){
            perror("mkfifo");
            exit(0);
        }
    }
    //2.判断有名管道文件是否存在（管道2）
    ret = access("fifo2",F_OK);
    if(ret==-1){
        printf("管道不存在，创建对应管道\n");
        ret = mkfifo("fifo2", 0664);
        if(ret == -1){
            perror("mkfifo");
            exit(0);
        }
    }
    //3.以只读的方式打开管道1
    int fdr = open("fifo1", O_RDONLY);
    if(fdr==-1){
        perror("open");
        exit(0);
    }
    printf("打开FIFO1成功，等待读取数据\n");
    //4.以只写的方式打开管道2
    int fdw = open("fifo1", O_WRONLY);
    if(fdw==-1){
        perror("open");
        exit(0);
    }
    printf("打开fifo2成功，等待写入数据\n");
    char buf[128];
    //4.循环读写数据
    while(1){
        //等待读取管道2数据
        memset(buf, 0, 128);
        ret = read(fdr, buf, 128);
        //如果没有可读取数据
        if(ret<=0){
            perror("read:");
            break;
        }
        printf("get: %s\n", buf);
        //获取标准输入
        memset(buf, 0, 128);
        fgets(buf, 128, stdin);
        //写数据
        ret = write(fdw, buf ,strlen(buf));
        if(ret == -1){
            perror("write");
            exit(0);
        }
    }
    //关闭文件描述符
    close(fdw);
    close(fdr);

    return 0;
}

2.4. 有名管道+父子进程实现聊天功能

　　使用g++，和gcc类似

　　chaA:

#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <iostream>
#include <fcntl.h>
#include <string.h>
using namespace std;

//进程A
int main(){
    pid_t pid = fork();
    int ret;
    if(pid == -1){
        perror("fork");
        exit(0);
    }
    //A进程本身（父进程），实现管道一的写入
    else if(pid>0){
        ret = access("fifo1", F_OK);
        if(ret==-1){
            cout<<"管道不存在，创建对应管道"<<endl;
            ret = mkfifo("fifo1", 0664);
            //管道创建失败
            if(ret==-1){
                perror("fifo1");
                exit(0);
            }
        }
        //以只写的方式打开管道一
        int fdw = open("fifo1", O_WRONLY);
        //打开失败
        if(fdw==-1){
            perror("open");
            exit(0);
        }
        printf("打开FIFO1成功，等待写入数据\n");
        //循环写入
        char buf[128];
        while(1){
            memset(buf,0,128);
            cin.getline(buf,128);
            ret = write(fdw, buf, strlen(buf));
            if(ret == -1){
                perror("write");
                exit(0);
            }
            
        }
        close(fdw);
    }
    //A进程的子进程，实现管道二的读取
    else if (pid == 0){
        ret = access("fifo2", F_OK);
        if(ret==-1){
            cout<<"管道不存在，创建对应管道"<<endl;
            ret = mkfifo("fifo2", 0664);
            //管道创建失败
            if(ret==-1){
                perror("fifo2");
                exit(0);
            }
        }
        //以只读的方式打开管道2
        int fdr = open("fifo2", O_RDONLY);
        //打开失败
        if(fdr==-1){
            perror("open");
            exit(0);
        }
        cout<<"打开FIFO2成功，等待读取数据"<<endl;
        //循环读取
        char buf[128];
        while(1){
            memset(buf, 0, 128);
            ret = read(fdr, buf, 128);
            //如果没有可读取数据
            if(ret<=0){
                perror("read:");
                break;
            }
            cout<<"get:"<<buf<<endl;
        }
        close(fdr);
    }
    return 0;
}

　　chatB:

#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <iostream>
#include <fcntl.h>
#include <string.h>
using namespace std;

//进程B
int main(){
    pid_t pid = fork();
    int ret;
    if(pid == -1){
        perror("fork");
        exit(0);
    }
    //B进程本身（父进程），实现管道一的读取
    else if(pid>0){
        ret = access("fifo1", F_OK);
        if(ret==-1){
            cout<<"管道不存在，创建对应管道"<<endl;
            ret = mkfifo("fifo1", 0664);
            //管道创建失败
            if(ret==-1){
                perror("fifo1");
                exit(0);
            }
        }
        //以只读的方式打开管道一
        int fdr = open("fifo1", O_RDONLY);
        //打开失败
        if(fdr==-1){
            perror("open");
            exit(0);
        }
        printf("打开FIFO1成功，等待读取数据\n");
        //循环读取
        char buf[128];
        while(1){
            memset(buf, 0, 128);
            ret = read(fdr, buf, 128);
            //如果没有可读取数据
            if(ret<=0){
                perror("read:");
                break;
            }
            cout<<"get:"<<buf<<endl;
        }
        close(fdr);
    }
    //B进程的子进程，实现管道二的写入
    else if (pid == 0){
        ret = access("fifo2", F_OK);
        if(ret==-1){
            cout<<"管道不存在，创建对应管道"<<endl;
            ret = mkfifo("fifo2", 0664);
            //管道创建失败
            if(ret==-1){
                perror("fifo2");
                exit(0);
            }
        }
        //以只写的方式打开管道2
        int fdw = open("fifo2", O_WRONLY);
        //打开失败
        if(fdw==-1){
            perror("open");
            exit(0);
        }
        cout<<"打开FIFO2成功，等待写入数据"<<endl;
        //循环写入
        char buf[128];
        while(1){
            memset(buf,0,128);
            cin.getline(buf,128);
            ret = write(fdw, buf, strlen(buf));
            if(ret == -1){
                perror("write");
                exit(0);
            }
        }
        close(fdw);
    }
    return 0;
}

三、内存映射

3.1 什么是内存映射

　　内存映射（Memory-mapped I/O）是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件。

3.2 操作内存映射函数void **mmap(void addr, size_t length, int prot, int flags, int fd, off_t offset);

　　有关系的进程间的通信：

/*
        #include <sys/mman.h>
        void *mmap(void *addr, size_t length, int prot, int flags,
                  int fd, off_t offset);
        功能：映射文件或者设备数据到内存中
        参数：
            -addr：所映射内存的首地址，传递NULL，由内核指定
            -length：要映射的内存的长度。这个值不能小于等于0，而且是内存分页的整数倍
                     建议使用文件的长度
                     获取文件长度stat/lseek。
            -prot：对申请内存映射区的操作权限，为整数宏，多个权限按位或
                    PROT_EXEC  可执行权限
                    PROT_READ  读权限
                    PROT_WRITE 写权限
                    PROT_NONE  没有权限
                    要操作映射内存必须要有读权限（无论写还是读）
            -flags
                -MAP_SHARED：映射区数据会自动和磁盘文件进行同步，要进程间通信必须要设置此权限
                -MAP_PRIVATE：内存映射改变，但是原来文件不修改，如果写数据时，会重新创建新文件。
                -MAP_ANONYMOUS：创建匿名映射（只能用在有关系的进程）， 文件描述符将被忽略，偏移量将设置为0
            -fd
                -文件描述符，open()获取，文件大小不能为0，open指定的权限必须大于prot权限
            -offset
                -偏移量，从offset开始。必须指定4k整数倍，0表示不偏移
        返回值：
            -成功：映射内存的首地址
            -错误：返回MAP_FAILED（void * -1）
        int munmap(void *addr, size_t length);
        功能：释放内存映射
        -参数：
            -addr：释放内存的首地址
            -length:和mmap指定的大小一致
*/
/*
    使用内存映射实现进程间通信
    1.有关系的进程：
        -1.在还没有子进程的时候通过唯一的父进程创建内存映射区
        -2.创建子进程
        -3.父子进程共享创建的内存映射区

    2.没有关系的进程：
        -1.准备一个大小非0的磁盘文件
        -2.进程A通过磁盘文件创建内存映射区
            -得到操作这块内存的指针
           进程B通过磁盘文件创建内存映射区
            -得到操作这块内存的指针
        -3.进程间通信
            TIP：内存映射的方式进程通信非阻塞

*/



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

int main(){
    //1.打开一个文件
    int fd = open("test.txt", O_RDWR);
    if(fd == -1){
        perror("open");
        exit(0);
    }
    int size = lseek(fd, 0, SEEK_END);//获取文件大小
    //2.获取文件映射区
    void *ptr = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if(ptr == MAP_FAILED){
        perror("mmap");
        exit(0);
    }
    pid_t pid = fork();
    //父进程读数据
    if(pid>0){
        wait(NULL);
        char buf[64];
        strcpy(buf, (char *)ptr);
        printf("read data:%s\n", buf);
        
    }
    //子进程写数据
    else if(pid==0){
        strcpy((char *)ptr, "nihao a my Dad!!!");
    }
    munmap(ptr, size);

    return 0;
}

3.3 内存映射的注意事项　

◼ 如果对mmap的返回值(ptr)做++操作(ptr++), munmap是否能够成功?
　　1.可以对ptr进行++操作
　　2.但是munmap(ptr,size)会错误
　　3.在++操作前，对ptr值进行拷贝
◼ 如果open时O_RDONLY, mmap时prot参数指定PROT_READ | PROT_WRITE会怎样?
　　会直接返回MAP_FAILED，无法成功创建内存映射
　　建议open()函数中的权限和prot参数权限保持一致
◼ 如果文件偏移量为1000会怎样?
　　偏移量必须为4K整数倍，会返回MAP_FAILED
◼ mmap什么情况下会调用失败?
　　1.当length==0时
　　2.当prot权限超过open
　　3.文件偏移量不为4K整数倍
◼ 可以open的时候O_CREAT一个新文件来创建映射区吗?
　　-可以，但是所创建的文件大小不能为0
　　-可以用lseek，truncate对文件进行拓展
◼ mmap后关闭文件描述符，对mmap映射有没有影响？
　　此时映射区仍然存在，只是文件描述符被关闭了，没有任何影响
◼ 对ptr越界操作会怎样
　　越界操作操作非法内存，会产生段错误

posted on 2021-12-04 19:40 焱琰阅读(280) 评论(0) 编辑收藏举报

刷新页面返回顶部

导航

公告

Linux多进程编程三——进程通信其一

一、进程通信基础

1.什么是进程通信

2.进程间通信方式分类

二、管道通信

1.匿名管道通信

1.概念

2.（匿名）管道特点

3.匿名管道相关指令和匿名管道创建

4.匿名管道读写特点

2.有名管道通信

2.1 有名管道的创建

2.2 有名管道的通信

2.3 使用有名管道完成简单的进程间聊天

2.4. 有名管道+父子进程实现聊天功能

三、内存映射

3.1 什么是内存映射

3.2 操作内存映射函数void **mmap(void addr, size_t length, int prot, int flags, int fd, off_t offset);

3.3 内存映射的注意事项

导航

公告

Linux多进程编程三——进程通信其一

一、进程通信基础

1.什么是进程通信

2.进程间通信方式分类

二、管道通信

1.匿名管道通信

1.概念

2.（匿名）管道特点

3.匿名管道相关指令和匿名管道创建

4.匿名管道读写特点

2.有名管道通信

2.1 有名管道的创建

2.2 有名管道的通信

2.3 使用有名管道完成简单的进程间聊天

2.4. 有名管道+父子进程实现聊天功能

三、内存映射

3.1 什么是内存映射

3.2 操作内存映射函数void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

3.3 内存映射的注意事项

3.2 操作内存映射函数void **mmap(void addr, size_t length, int prot, int flags, int fd, off_t offset);

3.3 内存映射的注意事项　