【Linux】进程间通信（IPC)

已于 2023-03-22 17:06:53 修改
阅读量745 收藏
点赞数 2
分类专栏： Linux 文章标签： linux 运维 服务器 Powered by 金山文档
于 2023-03-17 21:45:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l203018/article/details/129599352
版权

进程间通信方法：管道（命名管道），共享内存区，信号量，消息队列，套接字

管道

管道在内存中分配空间，如果断电则其中的数据就不在了。

必须有至少一个读和一个写

对管道的操作只有只读或只写两种方式，没有读写——这种形式是未定义的

如果程序中只有读或只有写则程序会被阻塞住。

有名管道（fifo）

有名管道可以在任意两个进程间通信,有名字。

fifo文件的大小永远为0

A程序：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
int main()
{
    int fdw = open("fifo",O_WRONLY);//打开fifo管道，只写,fdw为文件描述符
    if(fdw == -1)exit(1);//打开失败
    printf("fdw=%d\n",fdw);
    while(1)//输入数据
    {
        printf("input:\n");
        char buff[128]={0};//创建一个空间
        fgets(buff,128);//存放输入的东西

        if(strncmp(buff,"end",3)==0)break;//如果前三个字符为end则退出输入
        write(fdw,buff,strlen(buff));//写
    }
    close(fdw);
    exit(0);
}

B程序：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
int main()
{
    int fdr = open("fifo",O_RDONLY);//打开fifo管道，只读形式
    if(fdr == -1)exit(1);//打开失败，退出

    printf("fdr==%d\n",fdr);
    while(1)//一直读
    {
        char buff[128]={0};//创建一个空间
        int n = read(fdr,buff,127);//读文件描述符fdr指向的文件的内容到buff中
        if(n==0)break;//当读不到时退出程序
        printf("read(%d)：%s",n,buff);
    }
    close(fdr);
    exit(0);
}

写数据的一端一旦关闭，则读数据的一端也会被关闭，读的返回值为0。

读关闭，写产生异常，产生信号（SIGPIPE）13

要一起运行ab程序管道才能用，否则会被阻塞，可以开两个终端使用。

无名管道（pipe）

无名管道只能在父子进程间通信

管道的通信方式：半双工，允许二台设备之间的双向数据传输，但不能同时进行

其他的通信方式：

单工：不能同时收发，数据传输只支持数据在一个方向上传输

全双工：收发可以同时进行

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
int main()
{
   int fd[2];//fd[0] r,fd[1] w
    if(pipe(fd) == -1)//创建管道失败
    {
        printf("pipe err\n");
        exit(1);
    }
    pif_t pid = fork();//复制进程
    if(pid == -1)//复制失败
    {
        printf("fprk err\n");
        exit(1);
    }
    if(pid == 0)//子
    {
        close(fd[1]);//半双工，关闭写，下面要读
        char buff[128] = {0};
        read(fd[0],buff,127);
        printf("child buff=%s\n",buff);
    }
    else//父
    {
        close(fd[0]);//关闭读
        write(fd[1],"hello",5);//将hello写入fd[1]
        close(fd[1]);
    }
    exit(0);
}

管道的实现和顺序队列类似

信号量(sem)

信号量表示可用资源的数目，主要用来同步进程。

信号量的值如果只取 0,1，将其称为二值信号量。如果信号量的值大于 1，则称之为计数信号量；

pv操作：

可以进行原子操作，+1（v操作）释放资源，-1 （p操作）获取资源（用一个资源，资源减少）

一般取正数值，0代表资源没有了，p操作会被阻塞；

临界资源：同一时刻，只允许被一个进程或线程访问的资源（一个用完另外一个才能用）

临界区：访问临界资源的代码段

a程序：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
int main()
{
    for(int i=0;i<5;i++)
    {
        printf("A");
        fflush(stdout);//刷屏

        int n = rand()%3;//模拟做了一会其他的东西再继续
        sleep(n);

        printf("A");
        fflush(stdout);

        n = rand()%3;
        sleep(n);
    }
}

b程序：把a程序的输出A改成B

如果没有pv操作，会变成这样AB交叉输出，ab程序同时使用资源：

封装信号量

创建、获取已存在的信号量：semget()

对信号量的值加减一semop()

赋初始值、销毁semctl()

失败返回负一

首先：sem.h头文件声明一下

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/sem.h>
//需要用这个联合体内的val初始化信号量的值
union semun
{
    int val;
    struct semid_ds*buf;
    unsigned short *array;
    struct seminfo *__buf;
};
void sem_init();
void sem_p();
void sem_v();
void sem_destroy();

实现pv操作的封装

不同的进程使用相同的key值可以获取同一个信号量

#include"sem.h"

static int semid = -1;//信号量
void sem_init()
{
    semid = semget((key_t)1234,1,IPC_CREAT|IPC_EXCL|0600);//全新创建一个信号量
    if(semid==-1)//全新创建失败
    {//获取以前的
        semid = semget((key_t)1234,1,0600);
        //如果还是获取失败就是失败了
        if(semid==-1)
        {
            printf("semget err\n");
        }
        else//初始化
        {
            union semun a;
            a.val = 1;
            if(semctl(semid,0,SETVAL,a)==-1)
            {
                printf("semctl setval err\n");
            }
        }
    }   
}
void sem_p()
{
    struct sembuf buf;
    buf.sem_num = 0;//下标
    buf.sem_op = -1;//p操作
    buf.sem_flg = SEM_UNDO;//防止程序崩溃，崩溃自动执行v操作

    if(semop(semid,&buf,1)==-1)//找semid第0个元素-1
    {
        printf("op p err\n");
    }
}
void sem_v()
{
    struct sembuf buf;
    buf.sem_num = 0;//下标
    buf.sem_op = 1;//v操作

    if(semop(semid,&buf,1)==-1)
    {
        printf("op v err\n");
    }
}

void sem_destroy()
{
    if(semctl(semid,0,IPC_RMID)==-1)
    {
        printf("semctl rm err");
    }
}

将封装实现好的pv操作加到程序中

int main()
{
    sem_init();//创建或获取信号量id
    for(int i=0;i<5;i++)
    {
        sem_p();//p
        printf("A");
        fflush(stdout);

        int n = rand()%3;
        sleep(n);

        printf("A");
        fflush(stdout);
        sem_v();//v

        n = rand()%3;
        sleep(n);
    }

    sleep(10);
    sem_destroy();//销毁
}

a已经销毁了信号量，b最后就不用销毁了

最后同时运行ab程序，不会再出现两个程序同时使用资源的行为了，如下AA完一次再BB，然后AA……

ipcs可以查看消息队列、共享内存、信号量的使用情况，ipcrm可以对它们进行删除操作

-s信号量，-m共享内存，-q消息队列

销毁是把一组信号量都销毁

共享内存（shm）

a、b的逻辑空间中的某段物理内存用的同一块，这样a、b进程可以利用这块共享内存通信，不用像管道一样还需要拷贝。

shmget()创建或获取共享内存，返回共享内存的id，失败返回-1；

int shmget(key_t key, size_t size, int shmflg);

shmget(key,size,shmfkg);
key： 不同的进程使用相同的 key 值可以获取到同一个共享内存
size： 创建共享内存时，指定要申请的共享内存空间大小
shmflg: IPC_CREAT IPC_EXCL

shmat()将申请的共享内存的物理内存映射到当前进程的虚拟地址空间上

void* shmat(int shmid, const void *shmaddr, int shmflg);

shmat()成功返回返回共享内存的首地址，失败返回 NULL
shmaddr：一般给 NULL，由系统自动选择映射的虚拟地址空间
shmflg： 一般给 0， 可以给 SHM_RDONLY 为只读模式，其他的为读写

shmdt()断开当前进程的 shmaddr 指向的共享内存映射

shmdt()成功返回 0， 失败返回-1
int shmdt(const void *shmaddr);

test.c输出共享内存中的东西

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/shm.h>
#include<string.h>
int main()
{
    //获取共享内存
    int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);
    if(shmid==-1)
    {
        printf("shmid err");
        exit(1);
    }
    //链接
    char*p = (char*)shmat(shmid,NULL,0);
    if(p==(char*)-1)
    {
        printf("shmat err");
        exit(1);
    }
    //打印
    while(1)
    {
         if(strncmp(p,"end",3)==0)break;
         printf("%s\n",p);
         sleep(1);
    }
    //断开
    shmdt(p);
    //销毁共享内存
    if(shmctl(shmid,IPC_RMID,0)==-1)
        printf("shmctl err\n");
}

main.c，往共享内存中写入东西

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/shm.h>
#include<string.h>
int main()
{
    //创建共享内存
    int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);
    if(shmid==-1)
    {
        printf("shmid err\n");
        exit(1);
    }
//把共享内存映射过来
    char *s = (char*)shmat(shmid,NULL,0);//s指向共享内存
    if(s == (char*)-1)
    {
       printf("shmat err");
        exit(1);
    }
    while(1)
    {
        printf("input:\n");
        char buff[128] = {0};
        fgets(buff,128,stdin);

        strcpy(s,buff);

        if(strncmp(buff,"end",3)==0)
        {
            break;
        }
    }
//断开映射
    shmdt(s);
    exit(0);
}

为了让它写修改一次输出一次，可以使用信号量：

使用两个信号量s1==1,s2==0

更改后

main.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/shm.h>
#include<string.h>
#include"sem.h"
int main()
{
    //创建共享内存
    int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);
    if(shmid==-1)
    {
        printf("shmid err\n");
        exit(1);
    }
//把共享内存映射过来
    char *s = (char*)shmat(shmid,NULL,0);//s指向共享内存
    if(s == (char*)-1)
    {
        printf("shmat err");
        exit(1);
    }
    sem_init();
    while(1)
    {
        printf("input:\n");
        char buff[128] = {0};
        fgets(buff,128,stdin);

        sem_p(SEM_W);
        strcpy(s,buff);
        sem_v(SEM_R);
        if(strncmp(buff,"end",3)==0)
        {
            break;
        }
    }
//断开映射
    shmdt(s);
    exit(0);
}

test.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/shm.h>
#include<string.h>
#include"sem.h"
int main()
{
    //获取共享内存
    int shmid = shmget((key_t)1234,128,IPC_CREAT|0600);
    if(shmid==-1)
    {
        printf("shmid err");
        exit(1);
    }
    //链接
    char*p = (char*)shmat(shmid,NULL,0);
    if(p==(char*)-1)
    {
        printf("shmat err");
        exit(1);
    }
    //打印
    sem_init();
    while(1)
    {
        sem_p(SEM_R);
        if(strncmp(p,"end",3)==0)break;
        printf("%s\n",p);
        sem_v(SEM_W);
    }
    //断开
    shmdt(p);
    //销毁共享内存
    if(shmctl(shmid,IPC_RMID,0)==-1)
        printf("shmctl err\n");
    sem_destroy();
}

消息队列

ipcrm -q 0删消息队列

-s信号量，-m共享内存

在内存中创建

msgsnd()发送

msgrcv()接收

msgctl()移除

msggst()创建

a.c程序

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/msg.h>
struct mess//自己定义消息结构体
{
       long type;
       char buff[32];
};
 
int main()
{
       int msgid = msgget((key_t)1234,IPC_CREAT|0600);
       if(msgid==-1)
       {
              printf(“msggeterr”);
              exit(1);
    }
    //写入数据,程序运行一次写入一次
    struct mess dt;
    dt.type = 1;//1号消息
    strcpy(dt.buff,”hello1”);
    //添加到消息队列
    msgsnd(msgid,&dt,32,0);
     
}

再运行一遍a.c又加入一个消息，已用字节数：32->64

b.c程序

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/msg.h>
struct mess
{
       long type;
       char buff[32];
};
int main()
{
       int msgid =msgget((key_t)1234,IPC_CREAT|0600);
       if(msgid ==-1)
    {
           printf(“msgget err\n”);
           exit(1);
    }
    struct mess dt;
    //读取消息
    msgrcv(msgid,&dt,32,1,0);//倒数第二个参数为指定读取几号类型消息，若为0，所有消息都可以读（不区分消息类型）。
    printf(“dt.buff=%s\n”,dt.buff);
}

读消息会取出消息队列中的消息

曦樂～
关注
专栏目录
ipc.rar_IPC_linux 进程_进程间通信_进程间通信ipc
09-23
本文将深入探讨标题“ipc.rar_IPC_linux 进程_进程间通信_进程间通信ipc”所涉及的知识点，包括Linux下的管道（pipe）、进程以及进程间通信的基本概念、工作原理和应用实例。 首先，让我们理解什么是进程。在Linux...
linux进程间通信IPC方式
lx123010的专栏
03-27 841
Linux环境下，进程地址空间相互独立、彼此隔离，因此进程间的数据不能直接访问。如果要交换数据，必须要通过内核，在内核中开辟一块缓冲区，进程A把数据从用户空间拷贝到内核缓冲区，进程B再把数据从内核缓冲区拷贝走，内核提供的这种机制称为进程间通信（IPC, InterProcess Communication）。在Linux下由很多种进程间通信的方式，分别是：匿名管道(PIPE)、命名管道(FIFO)、信号、共享内存、消息队列、信号量、UNIX域套接字。现在常用的进程间通信方式有：管道（使用简单）
Linux进程间通信(Linux IPC)
Peerless__的博客
06-04 6771
在Linux下由很多种进程间通信的方式，在下面主要介绍七种，分别是：匿名管道(PIPE)、命名管道(FIFO)、信号、共享内存映射、共享内存、消息队列、信号量、UNIX域套接字。
Linux IPC解析：匿名命名管道与共享内存
最新发布
喜欢就坚持吧
08-01 1072
进程间通信）是计算机系统中不同进程之间交换数据和同步操作的机制。由于现代计算机系统中，程序通常会由多个进程组成，这些进程可能需要相互通信以完成任务，因此IPC非常重要。数据交换：允许不同进程共享数据或传递信息。同步：协调多个进程之间的操作，以避免竞态条件和资源冲突。互斥：控制多个进程对共享资源的访问，确保同一时间只有一个进程能够访问资源管道（Pipes）：匿名管道：用于相关进程之间的单向通信，如父子进程或兄弟进程。
Linux学习笔记10 - 进程间通信(IPC)(一)
我的博客
10-26 376
IPC - 管道
Linux下的多进程通信(IPC)原理及实现方案(管道-消息队列-信号量-共享内存-套接字)
热门推荐
程序员光剑
04-01 2万+
每一个基于TCP/IP网络通讯的程序(进程)都被赋予了唯一的端口和端口号，端口是一个信息缓冲区，用于保留Socket中的输入/输出信息，端口号是一个16位无符号整数，范围是0-65535，以区别主机上的每一个程序(端口号就像房屋中的房间号)，低于256的端口号保留给标准应用程序，比如pop3的端口号就是110，每一个套接字都组合进了IP地址、端口，这样形成的整体就可以区别每一个套接字。一个进程扮演客户端的角色，另外一个进程扮演服务器的角色，两个进程之间相互发送接收数据，这就是基于本地套接字的进程通信。
Linux进程间通信(IPC)
weixin_42581560的博客
01-02 569
Linux进程间通信，主要介绍了管道，命名管道，信号量，共享内存，消息队列
Linux IPC：共享内存
weixin_57761086的博客
03-17 1945
介绍了进程间通信方式：共享内存。对比了共享内存和管道的区别、以及它们的传输效率。介绍了操作共享内存的流程，以及操作共享内存的函数（参数和返回值），同时介绍了关于共享内存的指令。
深刻理解Linux进程间通信.pdf
08-16
Linux进程间通信（IPC）是操作系统中非常重要的部分，它包括多种机制用于进程间的数据交换。了解这些机制对于进行系统编程和软件开发非常重要。本文档详细介绍了管道、信号、消息队列、信号量和共享内存等通信方法。...
Linux进程通信（IPC）方式简介
09-15
Linux进程通信（IPC，Inter-Process Communication）是操作系统中一种重要的机制，允许不同的进程之间交换信息，协同工作。本文将简要介绍Linux下几种主要的IPC方式：管道（pipe）和有名管道（FIFO）、信号（signal...
进程间通信IPC(InterProcessCommunication)
01-27
【进程间通信IPC(InterProcess Communication)】 进程间通信（IPC）是指在操作系统中，不同进程之间为了交换信息而共享数据或同步行为的一种机制。由于每个进程都有自己独立的用户地址空间，它们之间的数据无法直接...
Linux进程间通信(IPC)-------消息队列
qq_45829112的博客
11-20 805
消息队列是进程间通信的一种方法，他有两个操作，一个进程来发送消息(也就是向内存中写入数据)，另一个是获取消息(也就是另外一个进程在内存中读取数据) 下面来看消息队列的 创建，写入，读取等需要用到的函数 创建：msgget((key_t) key,int msgflg) 其中(key_t)key的话，我在管道，共享内存中都写过，key值没什么要求，大于零的32位整数就行，并且它是用来区分和别的消息队列的，所以key值别和其他消息队列重复就行 msgflg是个标志位，一般取IPC_CR...
Linux:进程间通信IPC:共享内存
kb1122333的博客
12-10 138
共享内存 共享内存为多个进程之间共享和传递数据提供了一种有效的方式。共享内存是先在物理内存上申请一块空间，多个进程可以将其映射到自己 的虚拟地址空间中。 所有进程都可以访问共享内存中的地址，就好像它们是由 malloc 分配的一样。如果某个进程向共享内存写入了数据， 所做的改动将立刻被可以访问同一段共享内存的任何其他进程看到。由于它并未提供同步机制，所以我们通常需要用其他的机制来同步对共 享内存的访问。 共享内存示例代码 #include <sys/ipc.h> #include <sy
Linux——进程间通信(System V共享内存)
m0_57249790的博客
05-09 500
我们申请共享内存的时候也会申请一个数据结构对象，操作系统需要将共享内存管理起来，本质管理的就是共享对应的特定数据结构对象形成的数据结构进行操作的。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。我们在使用malloc(1024)在堆空间开辟空间的时候，只需要在free(p)中传入一个地址就可以准确的对我们开辟的空间进行释放，并不用传入我们需要开辟空间的大小。对应共享内存空间(进程地址空间里面的)的起始地址。
简析Linux IPC
weixin_43902324的博客
05-28 476
无名管道：速度慢，容量有限，只有父子进程能通讯有名管道：任何进程间都能通讯，速度慢信号：实现异步的软中断共享内存：能够很容易控制容量，速度快，但要注意同步问题信号灯集：不能传递复杂消息，只能用来同步。用于实现进程间的互斥与同步，而不是用于存储进程间通信数据消息队列：容量受到系统限制，要注意读的时候，要考虑上一次没有读完数据的问题。
Linux进程间通信（IPC）的五种方式
q1049459071Q的博客
03-02 526
对于Linux进程间通信本人的一点小小的笔记。
linux c 共享内存 shmget参数简介 IPC_CREAT、IPC_EXCL、0666
whatday的专栏
01-27 4188
int shmget(key_t key, size_t size, int flag); key: 标识符的规则 size: 共享存储段的字节数 flag:读写的权限还有IPC_CREAT或IPC_EXCL对应文件的O_CREAT或O_EXCL 返回值： 成功返回共享存储的id，失败返回-1 key_t key key标识共享内存的键值: 0/IPC_PRIVA...
进程间通信（IPC）
weixin_48006170的博客
10-02 885
进程间通信（IPC）介绍 进程间通信是指不同进程之间的信息传递或交互。 IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。 管道 管道，通常指无名管道，是 UNIX 系统IPC最古老的形式。 无名管道 1.特点 它是半双工的（数据只能在一个方向上流动），并且具有固定的读端和写端。 它只能在拥有血缘关系（父子进程或兄弟进程）的进程之间通信。 它可以看成是一种特殊的文件，对于它的读写可
Linux进程间通信IPC：管道与fork的运用
"调用fork后的半双工管道在Linux进程间通信中的应用" 在Linux操作系统中，进程间通信（IPC, Inter-Process Communication）是实现不同进程间数据交换和协作的重要机制。调用`fork()`函数后创建的父子进程可以通过...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

曦樂～

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

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

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

打赏作者

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

抵扣说明：

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

余额充值