linux系统编程-进程间通信

Posted 2024-09-9 Updated 2024-09- 9

By orbit

53~68 min read

进程间通信

进程间通信的常用方式，特征：

管道：简单
信号：开销小
mmap映射：非血缘关系进程间
socket（本地套接字）：稳定

管道：

实现原理：内核借助环形队列机制，使用内核缓冲区实现。

特质；

伪文件
管道中的数据只能一次读取。
数据在管道中，只能单向流动。

局限性：

自己写，不能自己读。
数据不可以反复读。
半双工通信。
血缘关系进程间可用。

pipe函数

pipe函数：创建，并打开管道。

int pipe(int fd[2]);

参数：	fd[0]: 读端。

	fd[1]: 写端。

返回值： 成功： 0

	 失败： -1 errno

管道的读写行为：

读管道：
1. 管道有数据，read返回实际读到的字节数。

管道无数据： 1）无写端，read返回0 （类似读到文件尾）

2）有写端，read阻塞等待。

写管道：

1. 无读端， 异常终止。 （SIGPIPE导致的）

2. 有读端： 1）管道已满，阻塞等待

2）管道未满，返回写出的字节个数。

pipe管道：用于有血缘关系的进程间通信。 ps aux | grep ls | wc -l

父子进程间通信：

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

int main(int argc, char const *argv[])
{
    int ret;
    int fd[2];
    int buff[1024];
    char *str="hello\n";
    ret = pipe(fd);
    int pid = fork();
    if (pid == 0){
        close(fd[1]);
        ret = read(fd[0], buff, strlen(str));
        printf("child read num %d\n", ret);
        write(STDOUT_FILENO, buff, ret);
        close(fd[0]);
    }else if (pid >0){
        close(fd[0]);
        write(fd[1], str, strlen(str));
        sleep(1);
        close(fd[1]);
    }
    return 0;
}

兄弟进程间通信：

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

int systemerror(char *str){
    perror(str);
    exit(1);
}


int main(int argc, char const *argv[])
{

    int i;
    int ret;
    int fd[2];
    pid_t pid,wpid;

    ret = pipe(fd);
    if (ret == -1){
        systemerror("pipe error");
    }
    for (i = 0; i < 2; i++)
    {
        pid = fork();
        if (pid == 0){
            break;
        }
    }

    if (i == 0){
        close(fd[0]);
        dup2(fd[1], STDOUT_FILENO);
        execlp("ls", "ls", NULL);
        // printf("child execl ls\n");
        // close(fd[1]);
        // exit(0);
    }else if (i == 1){
        close(fd[1]);
        dup2(fd[0], STDIN_FILENO);
        // ret = read(fd[0], buff, strlen(str));
        // printf("brother read num %d\n", ret);
        execlp("wc", "wc","-l", NULL);
    
        // write(STDOUT_FILENO, buff, ret);
        // close(fd[0]);
        // exit(0);
    }else if (i == 2) {
        close(fd[0]);
        // close(fd[1]);
        while((wpid = waitpid(-1,NULL,WNOHANG)) != -1){
            if (wpid > 0){
                printf("wait child finish : %d \n",wpid);
            }else{
                sleep(1);
                // printf("sleep 1s\n");
            }
        }
        // wait(NULL);
        // wait(NULL);
    }
    

    return 0;
}

fifo管道

fifo管道：可以用于无血缘关系的进程间通信。

命名管道： mkfifo

无血缘关系进程间通信：

读端，open fifo O_RDONLY

写端，open fifo O_WRONLY

文件实现进程间通信：

打开的文件是内核中的一块缓冲区。多个无血缘关系的进程，可以同时访问该文件。

共享内存映射

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);		创建共享内存映射

参数：
	addr： 	指定映射区的首地址。通常传NULL，表示让系统自动分配

	length：共享内存映射区的大小。（<= 文件的实际大小）

	prot：	共享内存映射区的读写属性。PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE

	flags：	标注共享内存的共享属性。MAP_SHARED、MAP_PRIVATE

	fd:	用于创建共享内存映射区的那个文件的 文件描述符。

	offset：默认0，表示映射文件全部。偏移位置。需是 4k 的整数倍。

返回值：

	成功：映射区的首地址。

	失败：MAP_FAILED (void*(-1))， errno
    
    
int munmap(void *addr, size_t length);		释放映射区。   

addr：mmap 的返回值
length：大小

使用注意事项：

用于创建映射区的文件大小为 0，实际指定非0大小创建映射区，出 “总线错误”。
用于创建映射区的文件大小为 0，实际制定0大小创建映射区，出 “无效参数”。
用于创建映射区的文件读写属性为，只读。映射区属性为读、写。出 “无效参数”。
创建映射区，需要read权限。当访问权限指定为 “共享”MAP_SHARED是， mmap的读写权限，应该 <=文件的open权限。只写不行。
文件描述符fd，在mmap创建映射区完成即可关闭。后续访问文件，用地址访问。
offset 必须是 4096的整数倍。（MMU 映射的最小单位 4k ）
对申请的映射区内存，不能越界访问。
munmap用于释放的地址，必须是mmap申请返回的地址。
映射区访问权限为 “私有”MAP_PRIVATE, 对内存所做的所有修改，只在内存有效，不会反应到物理磁盘上。
映射区访问权限为 “私有”MAP_PRIVATE, 只需要open文件时，有读权限，用于创建映射区即可。

mmap函数的保险调用方式：

1. fd = open（"文件名"， O_RDWR）;

2. mmap(NULL, 有效文件大小， PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

父子进程使用 mmap 进程间通信：

父进程先创建映射区。 open（ O_RDWR） mmap( MAP_SHARED );
指定 MAP_SHARED 权限
fork() 创建子进程。
一个进程读，另外一个进程写。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/wait.h>

void sys_err(char *str){
    perror(str);
    exit(1);
}

int var = 100;

int main(int argc, char const *argv[])
{
    int fd = open("temp", O_RDWR | O_CREAT | O_TRUNC, 0664);
    if(fd < 0){
        sys_err("open");
    }
    if(ftruncate(fd, 4) < 0){
        sys_err("ftruncate");
    }
    int len = lseek(fd, 0, SEEK_END);
    int *p = NULL;
    // p =(int *) mmap(NULL,len,PROT_WRITE|PROT_READ,MAP_SHARED,fd,0);
    p = mmap(NULL,len,PROT_WRITE|PROT_READ,MAP_PRIVATE,fd,0);
    if (p == MAP_FAILED) {
        sys_err("mmap");
    }
    int pid = fork();
    if (pid == 0) {
        *p = 2000;
        var = 2000;
        printf("child: %d==== var: %d \n ", *p,var);
    } else {
        sleep(1);

        printf("parent: %d==== var: %d \n ", *p,var);
        wait(NULL);
            int ret = munmap(p,len);
    if (ret < 0) {
        sys_err("munmap");
    }
    }
    return 0;
}

无血缘关系进程间 mmap 通信：

两个进程打开同一个文件，创建映射区。
指定flags 为 MAP_SHARED。
一个进程写入，另外一个进程读出。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/wait.h>

void sys_err(char *str){
    perror(str);
    exit(1);
}
struct student
{
    int no;
    char name[20];
    int age;
};

int main(int argc, char const *argv[])
{
    struct student stu = {1001, "zhangsan", 23};
    int fd = open("test_mmap", O_RDWR | O_CREAT | O_TRUNC, 0664);
    if(fd < 0){
        sys_err("open");
    }
    if(ftruncate(fd, sizeof(stu)) < 0){
        sys_err("ftruncate");
    }
    int len = lseek(fd, 0, SEEK_END);
    struct student *p = NULL;
    p = mmap(NULL,sizeof(stu),PROT_WRITE|PROT_READ,MAP_SHARED,fd,0);
    // p = mmap(NULL,len,PROT_WRITE|PROT_READ,MAP_PRIVATE,fd,0);
    if (p == MAP_FAILED) {
        sys_err("mmap");
    }
    close(fd);
    while (1)
    {
        memcpy(p,&stu,sizeof(stu));
        stu.no++;
        sleep(1);
    }
    int ret = munmap(p,len);
    if (ret < 0) {
        sys_err("munmap");
    }

    return 0;
}



#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/wait.h>

void sys_err(char *str){
    perror(str);
    exit(1);
}
struct student
{
    int no;
    char name[20];
    int age;
};


int main(int argc, char const *argv[])
{
    struct student stu;
    int fd = open("test_mmap", O_RDONLY, 0664);
    if(fd < 0){
        sys_err("open");
    }
    int len = lseek(fd, 0, SEEK_END);
    struct student *p = NULL;
    p = mmap(NULL,sizeof(stu),PROT_READ,MAP_SHARED,fd,0);
    if (p == MAP_FAILED) {
        sys_err("mmap");
    }
    close(fd);
    while (1)
    {
        printf("no:%d name:%s age:%d\n",p->no,p->name,p->age);
        sleep(1);
    }
    int ret = munmap(p,len);
    if (ret < 0) {
        sys_err("munmap");
    }

    return 0;
}

【注意】：无血缘关系进程间通信。mmap：数据可以重复读取。

fifo：数据只能一次读取。

匿名映射

匿名映射：只能用于血缘关系进程间通信。

p = (int *)mmap(NULL, 40, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);

linux

进程间通信

License: CC BY 4.0