Linux 网络编程笔记7 | 进程间通信

最新推荐文章于 2023-07-04 22:02:41 发布

嵌入式_Chen

最新推荐文章于 2023-07-04 22:02:41 发布

阅读量277

点赞数 1

分类专栏： Linux C网络编程文章标签： linux 进程间通信

本文链接：https://blog.csdn.net/jackjruit/article/details/115578393

版权

本文详细介绍了Linux系统中进程间通信（IPC）的各种方式，包括命令行参数、环境变量、wait/waitpid、内存映射文件、信号、有名管道、无名管道、XSI进程间通信（消息队列、共享内存、信号量集）、套接字通信、无名管道的特殊情况，以及各种通信方式的特点和使用场景。重点讲解了管道通信的工作原理和相关代码示例。

摘要由CSDN通过智能技术生成

十二、进程间通信

1.什么是进程间通信

Unix/Linux系统中每个进程都拥有独立的4G字节大小的虚拟内存空间。其中高地址的1G字节被映射到相同的物理内存区域，用于保存内核代码和数据。低地址的3G字节作为保存用户代码和数据的用户空间，被映射到彼此不同物理内存。因此同一个虚拟内存地址，在不同的进程中，会被映射到不同的物理内存区域，在多个进程之间以交换虚拟内存地址的方式交换数据是不可能的。鉴于进程之间天然的内存壁垒，为了能够在不同进程之间高效地交换数据，需要有一种专门的机制，这就是所谓的进程间通信(Inter-Process Communication, IPC)。

2.简单的进程间通信

1)命令行参数

进程1组织命令行参数->execl->进程2处理命令行参数

进程1：username，password
execl(..., "login", username, password, NULL)
                        |         |
进程2：               argv[1]    argv[2]

2)环境变量

进程1组织环境变量->execle->进程2处理环境变量
进程1：username，password
sprintf(envp[0], “USERNAME=%s”, username);
sprintf(envp[1], “PASSWORD=%s”, password);
execle(…, envp);
进程2：envp[0]->USERNAME=minwei
envp[1]->PASSWORD=tarena

3)wait/waitpid

进程1->fork/vfork+exec->进程2

wait/waitpid(..., &status); main->return ...;
                   ^       exit/_exit/_Exit(...)
                  |______________________|

4)内存映射文件

进程1[虚拟内存]-->文件区域<--[虚拟内存]进程2
        ^                        ^
        |________________________|

5)信号

进程1----信号+附加数据—>进程2

3.传统的进程间通信

1)有名管道

进程1<-管道文件->进程2
有i节点没有数据块，内存文件
全双工通信

2)无名管道

         / -无名管道-> \
父进程                     子进程
         \ <-无名管道- /

半双工通信

4.XSI进程间通信(SVR4)

1)消息队列：

进程1—消息3|消息2|消息1–>进程2

2)共享内存：

进程1[虚拟内存]->物理内存<-[虚拟内存]进程2

3)信号量集：

多个进程竞争有限的资源

5.套接字进程间通信(BSD)

进程1<-本地套接字文件->进程2
有i节点没有数据块，内存文件
以一种统一的编程模式和接口库，处理网络和本机通信。

6.有名管道

创建有名管道文件:mkfifo命令 mkfifo myfifo
echo ‘’hello word!‘’ >myfifo
另外一个终端上执行 cat myfifo.可看到

#include <sys/stat.h>
int mkfifo(const char* pathname, model_t mode);
成功返回0，失败返回-1。
pathname - 文件路径
mode - 权限模式
打开、关闭、读取和写入有名管道文件的方法与读写普通文件无异：open/read/write/close。
代码：wfifo.c

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#define FIFO_FILE "myfifo"
int main(void) {
   
    printf("创建管道...\n");
    if (mkfifo(FIFO_FILE, 0666) == -1) {
   
        perror("mkfifo");
        return -1;
    }
    printf("打开管道...\n");
    int fd = open(FIFO_FILE, O_WRONLY);
    if (fd == -1) {
   
        perror("open");
        return -1;
    }
    printf("发送数据...\n");
    for (;;) {
   
        printf("> ");
        char buf[1024];
        fgets(buf, sizeof(buf) / sizeof(buf[0]),
            stdin);
        if (!strcmp(buf, "!\n"))
            break;
        if (write(fd, buf, strlen(buf) * sizeof(
            buf[0])) == -1) {
   
            perror("write");
            return -1;
        }
    }
    printf("关闭管道...\n");
    if (close(fd) == -1) {
   
        perror("close");
        return -1;
    }
    printf("删除管道...\n");
    if (unlink(FIFO_FILE) == -1) {
   
        perror("unlink");
        return -1;
    }
    printf("完成！\n");
    return 0;
}

代码：rfifo.c

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#define FIFO_FILE "myfifo"
int main(void) {
   
    printf("打开管道...\n");
    int fd = open(FIFO_FILE, O_RDONLY);
    if (fd == -1) {
   
        perror("open");
        return -1;
    }
    printf("接收数据...\n");
    for (;;) {
   
        char buf[1024] = {
   };
        ssize_t rb = read(fd, buf, sizeof(buf) -
            sizeof(buf[0]));
        if (rb == -1) {
   
            perror("read");
            return -1;
        }
        // 写端已关闭且管道无数据
        if (!rb)
            break;
        printf("< %s", buf);
    }
    printf("关闭管道...\n");
    if (close(fd) == -1) {
   
        perror("close");
        return -1;
    }
    printf("完成！\n");
    return 0;
}

编程模型
进程A                          进程B
创建管道     mkfifo
打开管道     open              打开管道
读写管道     read/write        读写管道
关闭管道     close             关闭管道
删除管道     unlink

7.无名管道

#include <unistd.h>
int pipe(int pipefd[2]);
成功返回0，失败返回-1。
pipefd - 输出两个文件描述符：
pipefd[0]表示管道的读端
pipefd[1]表示管道的写端
1)父进程调用pipe函数在系统内核中创建无名管道对象，同时得到与该对象相关联的两个文件描述符，一个用于读取，另一个用于写入；
2)父进程调用fork函数，创建子进程，子进程复制父进程的文件描述符表，因此子进程也同样拥有可用于读写管道对象的两个文件描述符。
3)负责写数据进程关闭管道读端，即pipefd[0]，而负责读数据的继承关闭管道的写端，即pipefe[1]；
4)父子进程通过各自持有的文件描述符，分别向管道写入和读取数据，待完成通信后再各自关闭所持有的文件描述符，内核中的无关管道对象即被释放。
代码：pipe.c

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
int main(void) {
   
    printf("父进程：创建管道...\n");
    int pipefd[2];
    if (pipe(pipefd) == -1) {
   
        perror("pipe");
        return -1;
    }
    printf("父进程：创建子进程...\n");
    pid_t pid = fork();
    if (pid == -1) {
   
        perror("fork");
        return -1;
    }
    if (pid == 0) {
   
        printf("子进程：关闭写端...\n");
        close(pipefd[1]);
        printf("子进程：接收数据...\n");
        for(;;) {
   
            char buf[2014] = {
   };
            ssize_t rb = read(pipefd[0], buf,
                sizeof(buf) - sizeof(buf[0]));
            if (rb == -1) {
   
                perror("read");
                return -1;
            }
            if (!rb)
                break;
            fputs(buf, stdout);
        }
        printf("子进程：关闭读端...\n");
        close(pipefd[0]);
        printf("子进程：完成！\n");
        return 0;
    }
    printf("父进程：关闭读端...\n");
    close(pipefd[