Linux系统编程-进程间通信

已于 2022-07-07 22:09:04 修改
阅读量291 收藏
点赞数 8
分类专栏： Linux系统编程 文章标签： linux 进程通信 c语言 操作系统
于 2022-07-03 09:36:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yohe1937/article/details/125581164
版权

一. 概念

1.1 发展

  • 管道
  • System V进程间通信
  • POSIX进程间通信

1.2 分类

1.2.1 管道

  • 匿名管道pipe
  • 命名管道

1.2.2 System V IPC

  • System V 消息队列
  • System V 共享内存
  • System V 信号量

1.2.3 POSIX IPC

  • 消息队列
  • 共享内存
  • 信号量
  • 互斥量
  • 条件变量
  • 读写锁

1.3 作用

  • 数据传输
  • 资源共享
  • 通知事件
  • 进程控制

二. 管道

2.1 简述

从一个进程连接到另一个进程的一个数据流称为一个“管道”。

2.2 匿名管道

2.2.1 pipe接口

int pipe(int pipefd[2]);
// 作用：创建一个匿名管道(以读写方式打开同一个文件)
// pipefd[0] --> 以读方式打开   pipefd[1] --> 以写方式打开
// 如果成功就返回0，错误就返回-1或者错误码

2.2.2 画图演示

在这里插入图片描述

2.2.2 代码演示

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

int main()
{
    int pipefd[2] = {0};
    int ret_pipe = pipe(pipefd);
    if (ret_pipe != 0)
    {
        perror("pipe");
        return -1;
    }
    
    // 我们让子进程写，父进程读
    pid_t pid = fork();  // 创建子进程
    if (pid < 0)
    {
        perror("fork");
        return -1;
    }
    if (pid == 0)
    {
        // child
        close(pipefd[0]);  // 子进程关闭读端，留下写端
        while (1)
        {
            const char* msg = "hello world";
            write(pipefd[1], msg, strlen(msg));
            sleep(1);
        }
    }
    
    // parent
    close(pipefd[1]);  // 父进程进程关闭写端，留下读端
    char msg[64] = "";
    while (1)
    {
        int n = read(pipefd[0], msg, sizeof(msg) - 1);
        msg[n] = '\0';
        printf("child say: %s\n", msg);
    }
    return 0;
}

2.2.3 关闭写端

// 只关闭写端
int main()
{
    int pipefd[2] = {0};
    int ret_pipe = pipe(pipefd);
    
    // 让子进程写，父进程读
    pid_t pid = fork();
    if (pid == 0)
    {
        // child
        close(pipefd[0]);
        while (1)
        {
            char ch = 'a';
            write(pipefd[1], &ch, 1);
            close(pipefd[1]);  // 将写端关闭
            break;
        }
    }
    
    // parent
    close(pipefd[1]);
    char msg[1024*4 + 1] = "";
    while (1)
    {
        sleep(1);
        int n = read(pipefd[0], msg, sizeof(msg) - 1);
        if (n < 0)
        {
            break;
        }
        if (n == 0)  // n为0，说明读端已经关闭了
        {
            printf("file is empty！\n");
            break;
        }
        msg[n] = '\0';
        printf("child say: %c\n", msg[0]);
    }
    return 0;
}

2.2.4 关闭读端

// 关闭读端
int main()
{
    int pipefd[2] = {0};
    int ret_pipe = pipe(pipefd);
    
    // 让子进程写，父进程读
    pid_t pid = fork();
    if (pid == 0)
    {
        // child
        close(pipefd[0]);
        while (1)
        {
            char ch = 'a';
            write(pipefd[1], &ch, 1);
        }
    }
    
    // parent
    close(pipefd[1]);
    char msg[1024*4 + 1] = "";
    while (1)
    {
        sleep(1);
        int n = read(pipefd[0], msg, sizeof(msg) - 1);
        close(pipefd[0]);  // 关闭读端
        printf("child say: %c\n", msg[0]);
        break;
    }
    int status = 0;
    wait(&status);
    printf("exit_code: %d   signal: %d\n", (status >> 8) & 0xff, status & 0x7f);  // 打印signal为13
    return 0;
}

2.2.5 五个特点

  • 管道是一个只能单向通信的通信信道
  • 管道是面向字节流的
  • 仅限于具有血缘关系的进程进行通信
  • 管道自带同步机制，原子性写入
  • 管道的生命周期是随进程的

2.2.6 读写规则

没有数据读时

写端不写或者写得慢，读端要等写端

O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。

O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。

当管道满时

读端不读或者读得慢，写端要等读端

O_NONBLOCK disable： write调用阻塞，直到有进程读走数据

O_NONBLOCK enable：调用返回-1，errno值为EAGAIN

写端对应的文件描述符被关闭时

读端read读完pipe的数据后会读到0，可以根据检测到0判断写端已经关闭了

读端对应的文件描述符被关闭时

写端收到SIGPIPE信号直接终止程序

原子性

当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。

当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。

2.3 命名管道

2.3.1 概念

一个有名字的管道文件，可以像正常文件操作那样被打开，所以它可以用于不相关进程之间的通信。

2.3.2 创建命令和接口

# 1. 命令行上创建
mkfifo filename

// 2. C程序里面创建
// 成功返回0，失败返回-1
int mkfifo(const char* filename, mode_t mode);

2.3.3 server和client案例代码

// server
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>  // for open
#include <fcntl.h>  // for open
int main()
{
    umask(0);
    int ret = mkfifo(FILE_NAME, 0666);
    int fd = open("fifo", O_RDONLY);
    while (1)
    {
        char buf[64] = {0};
        ssize_t n = read(fd, buf, sizeof(buf));
        printf("n -- %d\n", n);
        buf[n-1] = '\0';
        
        if (strcmp(buf, "ls") == 0)
        {
            if (fork() == 0)
            {
                execl("/bin/ls", "ls", "-al", NULL);
            }
        }
        else if (strcmp(buf, "information") == 0)
        {
            if (fork() == 0)
            {
                execl("/usr/bin/information", "information", NULL);
            }
        }
        else if (strcmp(buf, "clear") == 0)
        {
            if (fork() == 0)
            {
                execl("/usr/bin/clear", "clear", NULL);
            }
        }
        else if (strcmp(buf, "close") == 0)
        {
            printf("OK, close the file!!!\n");
            break;
        }
        else
        {
            printf("client say: %s\n", buf);
        }
    }
    close(fd);
    return 0;
}

// client
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>  // for open
#include <fcntl.h>  // for open
int main()
{
    int fd = open("fifo", O_WRONLY);
    if (fd < 0)
    {
        perror("open");
    }
    printf("successful open, fd is %d\n", fd);
    while (1)
    {
        printf("请输入：");
        fflush(stdout);
        char buf[64] = {0};
        ssize_t n = read(0, buf, sizeof(buf));
        buf[n] = '\0';
        n = write(fd, buf, n);
        if (strcmp(buf, "close\n") == 0)
        {
            break;
        }
    }
    close(fd);
    return 0;
}

2.3.4 读写规则

打开操作是为读而打开FIFO时

O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO

O_NONBLOCK enable：立刻返回成功

打开操作是为写而打开FIFO时

O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO

O_NONBLOCK enable：立刻返回失败，错误码为ENXIO

2.4 匿名管道和命名管道的区别

  1. 匿名管道由pipe函数创建并且打开
  2. 命名管道由mkfifo命令或者函数创建，程序里面打开用open
  3. 匿名管道只能在有血缘关系的进程之间进行通信，而命名管道可以在不相关的进程之间通信

三. System V共享内存

3.1 简述

如下图，在物理内存上申请一块空间，然后让不同进程的虚拟内存通过页表映射挂接到这个这块空间，这块空间就能实现被不同进程共享了。共享内存在建立连接以后，在通信的时候不需要调用系统接口了，没有IO的处理，速度上是比管道快很多的。

在这里插入图片描述

3.2 函数接口

3.2.1 ftok

// 需要包含的头文件
#include <sys/types.h>  // for key_t
#include <sys/ipc.h>

// 函数声明
key_t ftok(const char* pathname, int proj_id);

// 一. 功能：一般是给像shmget这种接口生成一个key

// 二. pathname：自定义路径的名字

// 四. proj_id：自定义项目id

// 五. 返回值：成功就返回一个对应key，失败就返回-1

3.2.2 shmget

// 需要包含的头文件
#include <sys/ipc.h>
#include <sys/shm.h>

// 函数声明
int shmget(key_t key, size_t size, int shmflg);

// 一. 功能： 向物理内存申请共享内存

// 二. key：也就是ftok函数接口生成的

// 三. size：是共享内存的大小，建议写4KB（4096Byte）的整数倍，因为内存分配操作是以页为单位的，一页的大小就是4KB

// 四. shmflag：是一个位图映射的数据变量，主要的标志位有IPC_CREAT和IPC_EXCL
// IPC_CREAT 如果共享内存不存在，则创建一个共享内存，否则打开操作
// IPC_EXCL 只有在共享内存不存在的时候，新的共享内存才建立，否则就产生错误（单独使用没有意义）

// 五. 返回值（成功返回共享内存的标识码，失败返回-1）
// 1. 单独使用IPC_CREAT，如果key对应的共享内存不存在，就返回新申请共享内存的标识码，存在就返回返回其标识码
// 2. IPC_CREAT和IPC_EXCL一起使用，如果key对应的共享内存不存在，就返回新申请共享内存的标识码，存在就返回出错（意义：调用成功，保证返回的标识码的共享内存是新建的，而不是已经存在的）

3.2.3 shmctl

// 需要包含的头文件
#include <sys/ipc.h>
#include <sys/shm.h>

// 函数声明
int shmctl(int shmid, int cmd, struct shmid_ds* buf);

// 一. 功能： 控制共享内存

// 二. shmid：需要控制的共享内存的标识码

// 三. cmd：将要采取的动作（IPC_STAT, IPC_SET, IPC_RMID）
// IPC_STAT：把shmid_ds结构中的数据设置为共享内存的当前关联值
// IPC_SET：在进程有足够权限的前提下，把共享内存的当前关联值设置为shmid_ds数据结构中给出的值
// IPC_RMID：删除共享内存段（常用！！！）

// 四. buf：指向一个保存着共享内存的模式状态和访问权限的数据结构的指针（删除共享内存时可以传NULL）

// 五. 返回值：成功返回0，失败返回-1

3.2.4 shmat

// 需要包含的头文件
#include <sys/types.h>
#include <sys/shm.h>

// 函数声明
void* shmat(int shmid, const void* shmaddr, int shmflg);

// 一. 功能： 将进程的虚拟地址通过页表映射挂接到共享内存

// 二. shmid：需要控制的共享内存的标识码

// 三. shmaddr：指定虚拟地址，一般传NULL让系统自动找一块地址

// 四. shmflg：SHM_RDONLY，传这个过去为只读模式，否则为其他模式

// 五. 返回值：成功返回挂接上的虚拟地址，失败返回（void*）-1

3.2.5 shmdt

// 需要包含的头文件
#include <sys/types.h>
#include <sys/shm.h>

// 函数声明
int shmdt(const void* shmaddr)

// 一. 功能： 解除虚拟内存与共享内存的页面映射关系

// 三. shmaddr：需要去关联的虚拟地址

// 四. 返回值：成功返回0，失败返回-1

3.2.6 案例

// common.h文件
#include <stdio.h> 
#include <sys/types.h>  // for key_t
#include <sys/ipc.h> 
#include <sys/shm.h>   // for shmget 
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>  // for O_CREAT
#define PATH_NAME "./"
#define PROJ_ID 0x6666 
#define SIZE  4096

// server.c文件
#include "common.h" 
int main()
{   
    key_t key =  ftok(PATH_NAME, PROJ_ID);

    printf("key = %d\n", key);

    // 申请共享内存
    int shmid = shmget(key, SIZE, IPC_CREAT | IPC_EXCL | 0666);
    if (shmid == -1)
    {
        perror("shmget");
        exit(1);
    }

    printf("client success! shmid is %d\n", shmid);

   
    // 让虚拟内存和共享内存关联起来
    char* ptr = (char*)shmat(shmid, NULL, 0);
    //sleep(10);
    
    // 通信
    
    char ch = 'A';
    while(ch != 'Z')
    {
        *ptr = ch;
        ptr++;
        *ptr= '\0';
        ch++;
        sleep(1);
    }

    sleep(5);
    // 去关联
    shmdt(ptr);

    // 销毁共享内存
    int ret = shmctl(shmid, IPC_RMID, NULL);
    if (ret == -1)
    {
        perror("shmctl");
    }
    printf("Destruction of successful!\n");
    return 0;
}

// client.c文件
#include "common.h" 
int main()
{
    key_t key =  ftok(PATH_NAME, PROJ_ID);

    // 获取共享内存的标识码
    int shmid = shmget(key, SIZE, IPC_CREAT);
    if (shmid == -1)
    {
        perror("shmget");
        exit(1);
    }
    
    // 建立链接关系
    char* ptr = (char*)shmat(shmid, NULL, 0);
    
    // 通信
    int times = 26;
    while (times--)
    {
        sleep(1);
        printf("%s\n", ptr);
    }

    // 解除链接关系
    shmdt(ptr);

    
    return 0;
}

3.2.7 相关命令

# 1. 显示当前所有shmipc的信息
ipcs -m

# 2. 删除shmipc资源
ipcrm -m shmid  # shmid为共享内存的标识符
柿子__
关注
专栏目录
Linux系统编程——进程间通信
蹦跶跶
07-31 310
进程间通信1. 进程间通信2. 管道2.1 管道的概念：2.2 pipe函数2.3 管道的读写行为2.4 管道缓冲区大小2.5 管道的优劣3. FIFO 1. 进程间通信 Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，Inter Process
Linux系统编程进程间通信
weixin_44409309的博客
06-13 120
进程间通信简称IPC，就是在不同进程之间消息传递的方式 主要的方式有管道、消息队列、共享内存、信号、信号量等。 1.管道 管道包括无名管道和命名管道。 无名管道： 1.具有固定的读写端、是一种单双工的通信模式 2.只能用于有亲缘关系的进程（父进程和子进程） 3.只存在内核当中 命名管道： 1.可以在无关的进程之间进行通信 2.以一种特殊的文件形式存在文件系统之间（FIFO是一种文件类型） 相同点：都可以阻塞读写，都用于scoket的网络通信 无名管道 成功会返回值为0，失败返回值为-1。 管道建立成功时，会
Linux系统编程-进程间通信（IPC）常用方式详解
qq_42037383的博客
07-12 2423
进程间通信（IPC，Inter-Process Communication）是指在操作系统中，不同进程之间进行数据交换和信息传递的机制。这种通信允许正在运行的多个进程能够相互协作、共享数据或者进行同步操作，以实现更复杂的任务和功能。Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。
[Linux]----进程间通信之管道通信
拾至名瑰的博客
11-19 1774
首先我基于通信背景来带大家了解进程间通讯！！！进程是具有独立性的！—>进程间想交互数据数据，成本会非常高！—>如果我们多进程需要协同处理一件事情我们要明确一个点，进程独立了，不是彻底独立，有时候，我们需要双方能够进行一定程度的信息交互。正文开始！管道只能用来进行具有血缘关系的进程之间，进行进程间通信。常用于父子通信管道只能单向通信(内核的实现决定)—半双工的一种特殊情况管道自带同步机制(pipe满，writer等，pipe空，reader等)—自带访问控制管道是面向字节流的。
操作系统实验--进程间通信
海到无边天作岸 山登绝顶我为峰
09-27 8008
进程间通信 一、实验名称 进程间通信 二、实验内容 学生独立设计并实现消息传递系统进程间交换数据的任务。 三、实验原理和设计思路 在Linux系统下用signal()函数进行进程间通信，pipe()函数创建管道进行数据传送。 四、源代码 1.软中断通信 #include<unistd.h> #include<stdio.h> #include<signal.h> void waiting(),stop(); int wait_mark; main() { int p1,p
嵌入式Linux高级编程--04posix_进程间通信.ppt
09-17
嵌入式Linux高级编程--04posix_进程间通信 嵌入式Linux高级编程主要内容包括进程间通信，进程间通信的目的包括数据传输、共享数据、通知事件和资源共享。Linux进程间通信发展历程包括早期UNIX进程间通信、基于...
linux系统编程_linux系统编程-中文_
10-04
进程间通信（IPC）也是Linux系统编程的重要部分，包括管道、消息队列、共享内存、信号量和套接字等方法。了解这些机制如何协同工作，可以帮助你设计出高效的多进程和多线程程序。 最后，理解Makefile和构建系统是...
【LINUX】SHELL贪吃蛇
09-11 430
Show()#Mapdo;;;esacdone#Snakefor ((i=0;i++))doecho "*"done#Foodecho "0"dodoneMove();;;;esacArrayMovethenthenthenthenfithen。
navicate远程linux上的pgsql提示密码失败
记录、分享、合作、共赢
09-14 145
2、postgresql.conf文件中，修改listen_addresses。3、重启pgsql，例如：systemctl restart pgsql。1、pg_hba.conf文件中，ipv4下面的内容改成。4、如果问题还在，检查firewalld防火墙，执行。5、再次尝试连接，成功！
GDB的基本使用方法（之二）
相忘于江湖的专栏
09-14 472
要调试守护进程（daemon process）等已经启动的进程，或是调试陷入死循环而无法返回控制台的进程时，可以使用attach命令，形式是： (gdb) attach PID attach之后就能使用普通的gdb命令，因此可以通过print显示变量，也可以设置断点。 此外，回复程序运行一般可以使用continue命令。 确认了行为之后，需要在gdb和进程分离时使用detach命令： (gdb) detach
计算机网络30——Linux-gdb调试命令&makefile
最新发布
weixin_74681777的博客
09-14 358
在已经生成后，修改一个文件，重新执行时只会重新编译修改的文件，其余不会变。myapp是要生成的可执行文件的名字，main.c是依赖文件的名字。逐过程：next，如果调用其他函数，也不进入，直接进入下一条语句。编译时带-g为调试，带调试信息编译后的可执行文件更大。l 行号——行号的行在中间，向上向下展示10行。开始调试，断点默认停在main函数第一行。使用gdb 可执行文件名——进入调试。2、测试makefile文件（1）停在第一个断点处，开始调试。（1）准备一个main文件。如果没有修改，不会重新编译。
Linux IO模型（多路复用）
2301_77143270的博客
09-09 1190
【1】Linux IO模型：IO多路复用场景假设二假设妈妈有三个孩子，分别不同的房间里睡觉，需要及时获知每个孩子是否醒了，如何做？1.一直在一个房间呆着：看不到其他两个孩子2.每个房间不停的看：可以但是超级无敌累3.听孩子哭不哭：不可行，因为只有一个信号，分辨不出来哪个孩子哭4.妈妈在客厅呆着睡觉，孩子醒了之后会自己出来告诉妈妈醒了：既可以休息，也可以及时的获取还是是否醒了应用程序中同时处理多路输入输出流，若采用阻塞模式，得不到预期的目的；●。
Linux和C语言（Day10）
weixin_65095004的博客
09-10 1156
实现特定功能的代码块定义函数： 存储类型 数据类型 函数名(参数列表){ 实现特定功能的代码块 }
Linux 下 C/C++ 程序编译的过程
Teminator_的博客
09-08 9551
本文将介绍如何将 C/C++ 语言编写的程序转换成为处理器能够执行的二进制代码的过程，包括四个步骤：预处理（）编译（）汇编（）链接（在此之前，首先来看一下 GCC 工具链。
Linux CTF逆向入门
YJ_12340的博客
09-11 1091
ELF文件在各种平台下都通用，ELF文件有32位版本和64位版本，其文件头内容是一样的，只不过有些成员的大小不一样。在这个二进制文件中，符号没有被剥离，因此我们可以看到函数名称，这使得它更容易理解。节表头部（Section Headers）包含了描述文件节区的信息，比如大小、偏移等，但这些对二进制文件的执行流程来说并不重要。我们先来看看 ELF 文件头，如果想详细了解，可以查看ELF的man page文档。3、我们可以查看“.rodata ”部分的偏移量，可以更好的查看这些字符。它到底循环了多少个字符？
基于Linux文件编程实现处理Excel表格的数据
sakabu的博客
09-11 1289
因为是一行一行的处理数据，有些小伙伴可能会疑惑，数据为什么不会被覆盖，为什么不会得到同样的数据？我们要知道read函数的原理，你读一个字符，文件的光标就会移动一个位置，你下次再打开这个文件，他的光标位置是不变的，除非你用lseek函数来改变光标的位置，所以我们每读一行，再加上结束符'\0'就相当于一个字符串，然后立马处理数据并且写入结果文件；下次再去读数据文件，是从上一次读的位置的下一个开始读，所以才能得到一行一行的数据。什么时候读完？
Linux系统编程：进程间通信之管道详解
"Linux系统编程中的进程间通信是一个重要的主题，特别是管道(Pipe)作为一种常见的通信机制，被广泛用于父子进程或兄弟进程之间的数据传递。管道是半双工的，即数据只能单向流动，需要双向通信时需要两个独立的管道。...
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

柿子__

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值