进程间通信

已于 2025-03-09 12:18:41 修改
阅读量818 收藏 29
点赞数 29
分类专栏： Linux 文章标签： linux
于 2024-04-22 18:11:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74190188/article/details/138031509
版权
本文介绍了Linux系统中进程间通信（IPC）的相关知识，包括IPC的目的、本质和原则，详细讲解了管道（匿名管道和命名管道）、System V共享内存和信号量等通信方式，分析了它们的特点、使用方法及优缺点，还提及了查看和控制共享内存的命令。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

进程间通信介绍

目的：

本质：

原则：

​编辑

IPC分类;

管道：

 System V IPC:

POSIX IPC：

管道

什么是管道：

匿名管道：

管道的四种情况：

管道的特点：

命名管道：

通过命名管道实现任意进程间通信：

命名管道与匿名管道：

System V 共享内存

共享内存的基本构成：

共享内存函数：

创建共享内存： 

获取key：

将共享内存链接到进程地址空间： 

将共享内存与进程地址空间接触链接

控制共享内存：

 共享内存的优点：

共享内存的缺点：

共享内存实现进程间通信：

查看共享内存：

浅谈System V 信号量

进程互斥：

原子性：

信号量：
​​​​​​​

进程间通信介绍

进程间通信(IPC，InterProcess Communication)是指在不同进程之间传播或交换信息。主要匿名管道、命名管道、共享内存等。

目的：

1.数据传输：一个进程需要将它的数据发送给另一个进程。
2.资源共享：多个进程之间共享同样的资源。
3.通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
4.进程控制：有些进程希望完全控制另一个进程的执行，此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

上述功能往往需要多个进程协同工作，而进程之间又存在独立性，不同进程之间不能直接进行数据资源的传递，这时就需要借助进程间通信来完成不同进程间的数据资源的传递。

本质：

由于进程之间存在独立性，因此要让两个进程之间实现通信，首先要让不同进程看到同一份资源。

原则：

1.需要有交换数据的空间(内存)。

2.交换数据的空间不能由通信双方中的任何一方提供，需要由操作系统（OS）提供。

进程A、B之间要进行通信，无论是在进程A中开辟一块空间供A、B之间通信使用，还是在进程B中开辟一块空间供A、B之间通信使用，都会与进程之间的独立性相矛盾，因此只能由OS提供一块空间，供A、B通信使用。

IPC分类;

管道：

匿名管道(pipe)、命名管道。

 System V IPC:

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

POSIX IPC：

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

本文主要讲解管道和System V共享内存。

管道

什么是管道：

管道是Unix中最古老的进程间通信的形式，它是一个把两个进程连接起来的数据流。

管道通信是基于文件实现的，它的生命周期是随进程的，进程退出，则对应的管道销毁。

管道是单向的，只能一个进程写数据，另一个进程读数据，要想实现双向通信，需要创建两个管道。 

匿名管道：

顾名思义就是没有名字的管道。

创建匿名管道需要使用pipe函数:

#include <unistd.h>
int pipe(int fd[2]);

pipe函数的功能就是创建一个匿名管道，创建成功返回 0 ，创建失败返回 错误代码 。

其中fd是一个存储文件描述符的数组，是一个输出型参数，若匿名管道创建成功，fd[0]存储匿名管道的读端文件描述符，fd[1]存储匿名管道的写端文件描述符。

 

由于pipe函数不会返回匿名管道的标识符之类的信息，因此通过pipe创建的匿名管道，只能实现父子进程间的IPC。因为子进程会继承父进程的相关属性和数据。

 

实例：

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

void writer(pid_t wfd)
{
    char buffer[128]={0};
    const char*str="hello father,I am child";
    int count=0;
    pid_t id=getpid();
    while(1)
    {
        snprintf(buffer,sizeof(buffer),"message:%s,pid:%d,count:%d\n",str,id,count);
        write(wfd,buffer,sizeof(buffer));
        count++;
        sleep(1);
    }
}

void reader(pid_t rfd)
{
    char buffer[1024]={0};
    while(1)
    {
        ssize_t n=read(rfd,buffer,sizeof(buffer));
        printf("father get a message:%s",buffer);
    }
}

int main()
{
    
    int pipefd[2]={0};
    int n=pipe(pipefd);//创建一个管道，pipefd[0]表示管道的读端，pipefd[1]表示管道的写端
    if(n!=0)
    {
        printf("管道创建失败\n");
        return 0;
    }
    printf("pipefd[0],read:%d  pipefd[1],writ:%d\n",pipefd[0],pipefd[1]);

    pid_t id=fork();
    if(id==0)//子进程，写
    {
        close(pipefd[0]);//关闭读端
        writer(pipefd[1]);
        exit(-1);
    }

    //父进程，读
    close(pipefd[1]);//关闭写端
    reader(pipefd[0]);
    
    wait(NULL);
    return 0;
}

上述代码主要功能是，创建一个匿名管道，然后通过fork创建子进程，子进程保留管道的写端，关闭读端，父进程保留读端，关闭写端，子进程每隔一秒向管道中写入一条信息，并且有一个计数器记录子进程写了多少次，父进程读取信息。

管道的四种情况：

  • 管道内无数据 且 写端不写入也不关闭，读端会一直阻塞等待。

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

void writer(pid_t wfd)
{
    char buffer[128]={0};
    const char*str="hello father,I am child";
    int count=0;
    pid_t id=getpid();
    while(1)
    {
        printf("child pid:%d\n",getpid());
        count++;
        sleep(1);
    }
}

void reader(pid_t rfd)
{
    char buffer[1024]={0};
    while(1)
    {
        printf("begin read....\n");
        ssize_t n=read(rfd,buffer,sizeof(buffer));
        printf("read end\n");
        printf("father get a message:%s",buffer);
    }
}

int main()
{
    printf("father pid:%d\n",getpid());
    int pipefd[2]={0};
    int n=pipe(pipefd);//创建一个管道，pipefd[0]表示管道的读端，pipefd[1]表示管道的写端
    if(n!=0)
    {
        printf("管道创建失败\n");
        return 0;
    }

    pid_t id=fork();
    if(id==0)//子进程，写
    {
        close(pipefd[0]);//关闭读端
       
        writer(pipefd[1]);
        exit(0);
    }

    //父进程，读
    close(pipefd[1]);//关闭写端
    
    reader(pipefd[0]);
    
    wait(NULL);
    return 0;
}

 上述代码中，子进程虽然一直在运行，但是并没有往管道中写数据。

运行起来后可以发现，父进程阻塞在了read函数位置，等待子进程写入数据。

  • 管道内被写满 且 读端不读取也不关闭，则写端在写满管道后，阻塞等待数据被读取。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

void writer(pid_t wfd)
{
    char buffer[1]={1};
    int count=0;
    pid_t id=getpid();
    while(1)
    {
        printf("begin write....\n");
        write(wfd,buffer,sizeof(buffer));
        printf("write end\n");
        count++;
        printf("child pid:%d  count:%d\n",getpid(),count);
    }
}

void reader(pid_t rfd)
{
    char buffer[1024]={0};
    while(1)
    {
        printf("father pid:%d\n",getpid());
        sleep(1);
    }
}

int main()
{
    int pipefd[2]={0};
    int n=pipe(pipefd);//创建一个管道，pipefd[0]表示管道的读端，pipefd[1]表示管道的写端
    if(n!=0)
    {
        printf("管道创建失败\n");
        return 0;
    }

    pid_t id=fork();
    if(id==0)//子进程，写
    {
        close(pipefd[0]);//关闭读端
       
        writer(pipefd[1]);
        exit(0);
    }

    //父进程，读
    close(pipefd[1]);//关闭写端
    
    reader(pipefd[0]);
    
    wait(NULL);
    return 0;
}

上述代码中，父进程一直在运行，但是一直不从管道中读取数据，而子进程一直在向管道中写入数据，每次写入 1 字节数据，并计数。

可以发现，子进程在写入65536字节(64KB)数据后就不在写入了，一直阻塞在write函数，等待父进程读取数据。

  • 写端关闭后，因为read函数会返回独到的数据数量，所以读端会把管道中的数据读完，最后read函数会返回 0 ，标志读取结束。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

void writer(pid_t wfd)
{
    char buffer[128]={0};
    const char*str="hello father,I am child";
    int count=0;
    pid_t id=getpid();
    while(1)
    {
        snprintf(buffer,sizeof(buffer),"message:%s,pid:%d,count:%d\n",str,id,count); 
        write(wfd,buffer,sizeof(buffer));
        
        if(count==5)
        {
            printf("write end...\n");
            break;
        }
        count++;
        sleep(1);
    }
    close(wfd);
}

void reader(pid_t rfd)
{
    char buffer[1024]={0};
    while(1)
    {
        ssize_t n=read(rfd,buffer,sizeof(buffer));
        if(n==0)
        {
            printf("father get a %s n:%ld\n",buffer,n);
            printf("read end....\n");
            break;
        }
        else if(n>0)
        {
            printf("father get a %s n:%ld\n",buffer,n);
        }
        else
        {
            break;
        }
        sleep(1);
    }
}

int main()
{
    int pipefd[2]={0};
    int n=pipe(pipefd);//创建一个管道，pipefd[0]表示管道的读端，pipefd[1]表示管道的写端
    if(n!=0)
    {
        printf("管道创建失败\n");
        return 0;
    }

    pid_t id=fork();
    if(id==0)//子进程，写
    {
        close(pipefd[0]);//关闭读端
       
        writer(pipefd[1]);
        exit(0);
    }

    //父进程，读
    close(pipefd[1]);//关闭写端
    
    reader(pipefd[0]);
    
    wait(NULL);
    return 0;
}

 上述代码中，子进程写入五次数据后不再写入数据，并且把管道写端关闭，父进程读取到 0 后结束循环。

可以发现，最后read函数最后的返回值为0。

  • 读端关闭后，写端再继续写入已没有意义，OS会直接终止写端的写入操作（通过13号信号SIGPIPE，杀掉进程）。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

void writer(pid_t wfd)
{
    char buffer[128]={0};
    const char*str="hello father,I am child";
    int count=0;
    pid_t id=getpid();
    while(1)
    {
        snprintf(buffer,sizeof(buffer),"message:%s,pid:%d,count:%d\n",str,id,count); 
        write(wfd,buffer,sizeof(buffer));
        count++;
        sleep(1);
    }
}

void reader(pid_t rfd)
{
    char buffer[1024]={0};
    int cnt=0;
    while(1)
    {
        ssize_t n=read(rfd,buffer,sizeof(buffer));
        if(n==0)
        {
            printf("father get a %s n:%ld\n",buffer,n);
            printf("read end....\n");
            break;
        }
        else if(n>0)
        {
            printf("father get a %s n:%ld\n",buffer,n);
        }
        else
        {
            break;
        }
        cnt++;
        if(cnt==2)
        {
            printf("read end....\n");
            break;
        }
        sleep(1);
    }
    close (rfd);
}

int main()
{
    int pipefd[2]={0};
    int n=pipe(pipefd);//创建一个管道，pipefd[0]表示管道的读端，pipefd[1]表示管道的写端
    if(n!=0)
    {
        printf("管道创建失败\n");
        return 0;
    }
    //printf("pipefd[0],read:%d  pipefd[1],writ:%d\n",pipefd[0],pipefd[1]);

    pid_t id=fork();
    if(id==0)//子进程，写
    {
        close(pipefd[0]);//关闭读端
       
        writer(pipefd[1]);
        exit(0);
    }

    //父进程，读
    close(pipefd[1]);//关闭写端
    
    reader(pipefd[0]);
    int status=0;
    int rid=waitpid(id,&status,0);
    if(rid==id)
    {
        printf("exit code:%d ,exit signal :%d\n",WEXITSTATUS(status),status&0x7f);
    }
    return 0;
}

上述代码中，读端读入两次数据后直接关闭，写端一直循环。 最后通过等待子进程获得子进程的退出信息。

可以发现，当读端关闭后，写端也立即终止了写入操作，OS发送13号信号杀掉子进程。

管道的特点：

1.只能用于具有亲缘关系的进程之间进行通信；通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。
2.管道是面向字节流的，读取和写入的次数没有必然关系。
3.一般而言，进程退出，管道释放，所以管道的生命周期随进程。
4.一般而言，内核会对管道操作进行同步与互斥。
5.管道是半双工的，数据只能向一个方向流动。需要双方通信时，需要建立起两个管道。

命名管道：

匿名管的一大限制就是只能用于父子进程间通信。

想要实现任意进程间的通信，可以使用FIFO文件来实现，它被称为命名管道。

命名管道是一种特殊类型的文件。

注意：

命名管道是一种特殊类型的文件，可以被打开，但是不会将内存数据刷新到磁盘中，相对于匿名管道来说，命名管道有文件名，并且存在于系统路径中。

  • 命名管道可以从命令行上创建：

使用命令：mkfifo + 命名管道的名字(不带路径，默认在当前目录下创建)

mkfifo file

 执行上述命令后，会在当前目录下创建一个管道文件file。

p 就表示该文件是一个管道文件，并且管道文件的后边有一个 | 标志。

  • 使用程序代码创建命名管道：
#include <sys/types.h>
#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);

pathname是一个字符串指针，指向的是命名管道的名字(可加路径，也可不加路径)，mode是所创建出来的命名管道文件的权限。

既然有创建命名管道的函数，就有删除命名管道的函数：

#include <unistd.h>
int unlink(const char *pathname);

两个函数都是执行成功返回 0 ，失败返回非 0 ，并设定错误码。

#include <iostream>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h> 

using namespace std;
int main()
{
    umask(0);
    int n=mkfifo("file",0666);
    if(n==0)
    {
        cout<<"makfifo success"<<endl;
    }
    else
    {
        cerr<<"mkfifo failed,errno:"<<errno<<endl;
        exit(-1);
    }
    sleep(5);

    n=unlink("file");
    if(n==0)
    {
        cout<<"unlink success"<<endl;
    }
    else
    {
        cerr<<"unlink failed,errno:"<<errno<<endl;
        exit(-1);
    }
    return 0;
}

上述代码，先在当前目录下创建一个file管道文件，5s后再把file管道文件删除。 

通过命名管道实现任意进程间通信：

  •  FIFO.hpp---创建管道

 通过FIFO类封装mkfifo函数，创建管道。

#pragma once
#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>

using namespace std;

#define MODE 0666   //创建管道的默认权限
#define PATH "./fifo"//创建管道的默认路径和名字

//创建一个命名管道
class FIFO
{
public:
    FIFO(const string& path=PATH)
        :_path(path)
    { 
        umask(0);//设置系统默认权限掩码为0

        int n=mkfifo(_path.c_str(),MODE);

        if(n!=0)
        {
            cerr<<"mkfifo failed,errno:"<<errno<<",errno message:"<<strerror(errno)<<endl;
        }
        else
        {
            cout<<"mkfifo success!"<<endl;
        }
    }

    ~FIFO()
    {
        int n=unlink(_path.c_str());
        if(n==0)
        {
            cout<<"unlink success!"<<endl;
        }
        else
        {
            cerr<<"unlink failed,errno:"<<errno<<",errno message:"<<strerror(errno)<<endl;
        }
    }
private:
    string _path;//路径+管道名字
};
  • PipeClient.cpp---客户端，写数据

 以只写方式打开管道文件，并不断从终端读取数据，写入到管道文件中。

#include"FIFO.hpp"

//客户端--写
int main()
{
    int wfd=open(PATH,O_WRONLY);
    if(wfd<0)
    {
        cerr<<"open failed,errno:"<<errno<<",errno message:"<<strerror(errno)<<endl;
        return 1;
    }

    string buffer;
    while(1)
    {
        getline(cin,buffer);
        if(buffer=="quit")
        {
            break;
        }

        ssize_t n=write(wfd,buffer.c_str(),buffer.size());//向管道中写数据
        if(n<0)
        {
            cerr<<"write failed,errno:"<<errno<<",errno message:"<<strerror(errno)<<endl;
        }
        sleep(1);
    }
    close(wfd);
    return 0;
}
  • PipeServer.cpp----服务端，读数据

以只读方式打开管道文件，并不断从管道文件中读取数据。 

#include"FIFO.hpp"

//服务端--读
int main()
{
    FIFO fifo(PATH);

    int rfd=open(PATH,O_RDONLY);
    if(rfd<0)
    {
        cerr << "open failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
        return 1;
    }
    cout<<"Server success!!"<<endl;

    char buffer[1024];
    while(1)
    {
        int n=read(rfd,buffer,sizeof(buffer)-1);

        if(n==0)
        {
            cout<<"Client quit!!!"<<endl;
            break;
        }
        else if(n<0)
        {
            cerr << "read failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
            break;
        }
        else
        {
            buffer[n]=0;//结束标志
            cout<<"Client say:"<<buffer<<endl;
        }
    }

    close(rfd);
    return 0;
}

运行结果：

命名管道与匿名管道：

  • 匿名管道由pipe函数创建并打开。
  • 命名管道由mkfifo函数创建，由open函数打开。
  • 命名管道有文件名，且会存在于系统路径中。
  • 匿名管道没有文件名，也不会存在于系统路径中。
  • 匿名管道与命名管道的最大的区别在于它们创建与打开的方式不同，一旦创建并打开后，它们具有相同的语义。

System V 共享内存

共享内存 是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，即进程不再通过执行进入内核的系统调用来传递彼此的数据。

 共享内存的生命周期是随内核的，需要手动释放，或者系统退出，内存空间才会释放。

使用共享内存进行通信一定是一个进程创建共享内存，另一个进程直接获取这个共享内存。 

共享内存的基本构成：

共享内存是由操作系统维护的，由于在操作系统中可能存在大量使用共享内存进行通信的进程，为了管理这些共享内存，操作系统除了要在物理内存中开辟共享内存之外，还必须对共享内存进行管理---先描述，再组织。所以，共享内存 = 共享内存块 + 描述共享内存的数据结构。

共享内存函数：

  • 创建共享内存： 

#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);

参数：

  • key：这个共享内存段在内核中的唯一性标识，在内核角度区分共享内存的唯一性，必须使用户手动传入，否则无法让任意两个进程看到同一块共享内存。
  • size：共享内存的大小，一字节为单位。系统实际分配时是以4KB为单位分配的。
  • shmflg：权限标志位，用法与创建文件时使用的mode标志类似。

shmflg常用的标记有三个：

  • IPC_CREAT：如果key标识的共享内存不存在，就创建；存在，就获取。
  • IPC_EXCL：不能单独使用，没有意义。
  • IPC_CREAT | IPC_EXCL：若key标识的共享内存不存在，就创建；存在，就出错返回。

可以在shmflg后边追加创建的共享内存的权限。

如：IPC_CREAT | 0666：表示不存在就创建，存在就获取，并且设定共享内存权限为666。

返回值：

  • 成功返回一个非负数，即创建的共享内存的标识码；失败返回 -1；
  • 该返回值不同于key，key仅创建共享内存时使用，在需要使用该共享内存时，都需要使用该返回值。

创建更新内存时需要手动传入一个key，这个key通常借助 ftok 函数获得：

  • 获取key：

#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);

参数：

  • pathname：给定一个字符串。
  • proj_id：给定一个常数。

返回值：

  • 返回一个具有唯一性的数值key。

  • 将共享内存链接到进程地址空间： 

#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);

参数：

  • shmid：共享内存标识码，即shmget函数的返回值。
  • shmaddr：指定链接地址，通常设置为NULL，让OS自己选择一个合适的位置。
  • shmflg：关联共享内存时设置的某些属性，它的两个可能取值是SHM_RND和SHM_RDONLY，一般设置为 0 ，默认设置为读写权限。

返回值：

  • 成功，返回指向共享内存第一个字节的指针；失败，返回-1。

  • 将共享内存与进程地址空间接触链接

#include <sys/types.h>
#include <sys/shm.h>

int shmdt(const void *shmaddr);

参数：

  • shmaddr：由shmat所返回的指针。

返回值：

  • 成功，返回0；失败返回 -1。

需要注意，shmdt函数只是把共享内存与进程的链接断开，并不是删除共享内存。

  • 控制共享内存：

#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

参数：

  • shmid：共享内存标识码，即shmget函数的返回值。
  • cmd：标记要对共享内存采取的操作。
  • buf：指向一个保存着共享内存的模式状态和访问权限的数据结构。

cmd有三个：

  • IPC_STAT：把当前共享内存中的属性拷贝到buf指向的结构体中。
  • IPC_SET：在权限足够的前提下，把共享内存的属性设置为buf指向的结构体中的数据。
  • IPC_RMID：删除共享内存。

 共享内存的优点：

  • 共享内存是最快的IPC形式。

共享内存的缺点：

  • 共享内存不提供进程间通信的协同机制。可以通过一个管道实现进程间的协同机制。
  • 默认情况下，共享内存的读取方不会管写入方是否写入数据，即使为空也会读取。

共享内存实现进程间通信：

  • Com.hpp：

主要是有关共享内存操作的一些函数和创建共享内存时需要用到的数据：

#pragma once

#include <iostream>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <string>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <unistd.h>
#include "FIFO.hpp"

using namespace std;

const char* pathname="/root/PFG";
const int Proj_id=0x66;


const int Default_Size=4096;//单位字节，共享内存以4KB为单位创建

//将key转成16进制
string ToHex(key_t key)
{
    char buffer[1024]={0};
    snprintf(buffer,sizeof(buffer),"0x%x",key);
    return buffer;
}

//获取开辟共享内存的标识符key
key_t GetShmKey()
{
    key_t key=ftok(pathname,Proj_id);
    if(key<0)//获取key失败,打印错误信息并退出
    {
        cerr<<"GetShmKey failed,errno:"<<errno<<",error message:"<<strerror(errno)<<endl;
        exit(1);
    }

    return key;
}

//使用shmget函数创建共享内存
int _CreateShm(key_t key,size_t size,int shmflag)
{
    int shmid=shmget(key,size,shmflag);
    if(shmid<0)//创建共享内存失败
    {
        cerr<<"shmget failed,errno:"<<errno<<",errno message:"<<strerror(errno)<<endl;
        exit(2);
    }

    return shmid;
}

//创建新的共享内存
int CreateShm(key_t key,size_t size)
{
    //IPC_CREAT:key标识的共享内存，不存在就创建，存在就获取它的shmid
    //IPC_EXCL:单独使用没有意义
    //IPC_CERAT|IPC_EXCL:key标识的共享内存，不存在就创建，存在就出错返回
    return _CreateShm(key,size,IPC_CREAT|IPC_EXCL|0666);//0666--给共享内存设置权限
}

//获取共享内存
int GetShm(key_t key,size_t size)
{
    return _CreateShm(key,size,IPC_CREAT|0666);
}

//删除共享内存
void DelShm(int shmid)
{
    int n=shmctl(shmid,IPC_RMID,nullptr);
    if(n<0)
    {
        cerr<<"DelShm failed,errno:"<<errno<<"errno message:"<<strerror(errno)<<endl;
    }
    else
    {
        cout<<"DelShm success,shmid:"<<shmid<<endl;
    }
}

//输出共享内存的属性
void DebugShm(int shmid)
{
    struct shmid_ds buf;
    int n=shmctl(shmid,IPC_STAT,&buf);//把共享内存的属性信息拷贝到buf中
    if(n<0)
    {
        cerr<<"DebugShm failed,errno:"<<errno<<"errno message:"<<strerror(errno)<<endl;
    }

    cout<<"shmid_ds.shm_segsz:"<<buf.shm_segsz<<endl;//共享内存大小
    cout<<"shmid_ds.shm_atime:"<<buf.shm_atime<<endl;//共享内存最后一次挂接的时间
    cout<<"shmid_ds.shm_dtime:"<<buf.shm_dtime<<endl;//共享内存最后一次脱离的时间
    cout<<"shmid_ds.shm_ctime:"<<buf.shm_ctime<<endl;//共享内存最后一次修改的时间
    cout<<"shmid_ds.shm_perm.__key:"<<ToHex(buf.shm_perm.__key)<<endl;//共享内存的key值
}

//挂载共享内存
void* AttachShm(int shmid)
{
    void* addr=shmat(shmid,nullptr,0);//系统自动选择一个地址，与shmid标识的共享内存进行连接
    if((long long)addr==-1)
    {
        cerr<<"AttachShm failed,errno:"<<errno<<"errno message:"<<strerror(errno)<<endl;
        return nullptr;
    }
    cout<<"AttachShm success"<<endl;
    return addr;
}

//解挂共享内存
void DetachShm(void* addr)
{
    int n=shmdt(addr);
    if(n<0)
    {
        cerr<<"DetachShm failed,errno:"<<errno<<"errno message:"<<strerror(errno)<<endl;
        return;
    }
    cout<<"DetachShm success"<<endl;
}
  • FIFO.hpp：

共享内存不提供进程间的协同机制，需要人为控制。

#pragma once
#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <assert.h>

using namespace std;

#define MODE 0666   //创建管道的默认权限
#define PATH "./fifo"//创建管道的默认路径和名字

//创建一个命名管道
class FIFO
{
public:
    FIFO(const string& path=PATH)
        :_path(path)
    { 
        umask(0);//设置系统默认权限掩码为0

        int n=mkfifo(_path.c_str(),MODE);

        if(n!=0)
        {
            cerr<<"mkfifo failed,errno:"<<errno<<",errno message:"<<strerror(errno)<<endl;
        }
        else
        {
            cout<<"mkfifo success!"<<endl;
        }
    }

    ~FIFO()
    {
        int n=unlink(_path.c_str());
        if(n==0)
        {
            cout<<"unlink success!"<<endl;
        }
        else
        {
            cerr<<"unlink failed,errno:"<<errno<<",errno message:"<<strerror(errno)<<endl;
        }
    }
private:
    string _path;//路径+管道名字
};

class Sync//通过命名管道控制共享内存读写协同
{
public:
    Sync()
        :rfd(-1),wfd(-1)
    {}

    void OpenRead()
    {
        rfd=open(PATH,O_RDONLY);
        if(rfd<0)
        {
            cerr<<"OpenRead failed,errno:"<<errno<<",errno message:"<<strerror(errno)<<endl;
            exit(1);
        }
    }

    void OpenWrite()
    {
        wfd=open(PATH,O_WRONLY);
        if(wfd<0)
        {
            cerr<<"OpenWrite failed,errno:"<<errno<<",errno message:"<<strerror(errno)<<endl;
            exit(1);
        }
    }

    bool Wait()//读端等待写端写入
    {
        bool ret=true;
        int temp=0;
        int n=read(rfd,&temp,sizeof(temp));
        if(n==sizeof(temp))
        {
            cout<<"Sever begin read shm......"<<endl;
        }
        else
        {
            ret=false;
        }
        return ret;
    }

    void Wakeup()//写端唤醒读端读取
    {
        int temp=0;
        int n=write(wfd,&temp,sizeof(temp));
        assert(n==sizeof(temp));
        cout<<"Server Wake..."<<endl;
    }

private:
    int rfd;
    int wfd;
};
  • ShmClient.cpp：

用户端----写入数据。

#include"Com.hpp"

//用户端--写
int main()
{
    key_t key = GetShmKey();
    cout << "key: " << ToHex(key) << endl;
    

    int shmid = GetShm(key, Default_Size);
    cout << "shmid: " << shmid << endl;
    DebugShm(shmid);

    char* addr=(char*)AttachShm(shmid);
    memset(addr,0,Default_Size);

    Sync sy;
    sy.OpenWrite();

    sleep(10);
    for(int i=0;i<26;i++)//写入数据
    {
        addr[i]=i+'a';
        sleep(1);
        sy.Wakeup();//唤醒服务端读取
    }

    cout<<"Client end"<<endl;
    DetachShm(addr);

    sleep(5);
    //DelShm(shmid);
    return 0;
}
  • ShmServer.cpp：

服务端----读取数据。

#include"Com.hpp"

//服务端--读
int main()
{
    // 1. 获取key
    key_t key = GetShmKey();
    cout << "key: " << ToHex(key) << endl;
    // sleep(2);

    // 2. 创建共享内存
    int shmid = CreateShm(key, Default_Size);
    cout << "shmid: " << shmid << endl;

    DebugShm(shmid);
    sleep(2);

    //挂载
    char* addr=(char*)AttachShm(shmid);

    FIFO fi;
    Sync sy;
    sy.OpenRead();
    
    //int count=40;
    while(1)
    {
        if(!sy.Wait())//等待写端写入
        {
            break;
        }
        cout<<"read success:"<<addr<<endl;
        sleep(1);
    }

    cout<<"Server end"<<endl;
    DetachShm(addr);
    sleep(5);
    // 3. 删除
    DelShm(shmid);
    return 0;
}

运行结果：

查看共享内存：

  • ipcs + -m  ：可以查看已创建的共享内存。
  • ipcrm + -m + shmid ： 删除指定的共享内存块。（shmid是共享内存的标识符，即shmget函数的返回值）

 System V 消息队列 与共享内存有许多相似之处，感兴趣的可以自己摸索研究一下，这里就不在赘述了。

浅谈System V 信号量

信号量主要用于同步和互斥。

System V IPC资源的生命周期随内核的，IPC资源必须手动删除，否则不会自动清除，除非重启系统。

进程互斥：

  • 由于各进程要求共享资源，而且有些资源需要互斥使用，因此各进程间竞争使用这些资源，进程的这种关系为进程的互斥。
  • 系统中某些资源一次只允许一个进程使用，称这样的资源为临界资源或互斥资源。
  • 在进程中涉及到互斥资源的程序段叫临界区。

注：

  • 临界资源需要被保护，保护临界资源的实质就是保护临界区。

原子性：

在操作对象时只有两种状态，要么没开始、要么已经结束。

信号量：

信号量又称信号灯，本质是一个描述临界资源的计数器(类似于一个int count，当有进程申请信号量成功就count--，有进程释放信号量就count++)，是对资源的预定机制。被预定的资源不一定被预定者持有，才是预定者的，只要预定者预定了，那么在未来的某一个时间，这份资源就是预定者的。

任何进程要访问临界资源，都需要申请信号量，只有申请成功才能访问资源，申请失败就继续等待，申请信号量又被称为P操作。信号量申请成功后，就可以访问资源。最后释放掉信号量，便于其他进程申请使用，释放信号量又被称为V操作。

注意：

  • 任何进程要访问临界资源，都需要申请信号量，则意味着所有进程都能看到同一个信号量，说明信号量本身就是共享资源，那么信号量的申请和释放都必须是原子性的。
  • 由于信号量是共享资源，因此单纯的int型数据，并不能充当信号量。                            原因有两点：

        1.单纯的 int 型数据无法在进程间共享，无法让所有进程都看到同一份资源。

        2.int类型的++ 、- 操作不是原子性的。

  • 通过申请信号量和释放信号量来保护临界资源，是所有进程都要遵守的规则。       
Linux-进程间通信
AI_ELF的博客
08-23 7171
数据传输：一个进程需要将它的数据发送给另一个进程资源共享：多个进程之间共享同样的资源。通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
Linux 进程间通信（管道）
2201_75663820的博客
09-22 2218
进程间通信、匿名管道、命名管道 ...
进程间通信详解
向未来❀去探索 的博客
06-26 1万+
进程间通信详解(命名管道，匿名管道，共享内存)
进程间通信之共享内存
k5426244的博客
07-19 2306
1.进程间通信的分类：（1）管道：1、匿名管道pipe;2、命名管道mkfifo（2）System V IPC：1、System V 消息队列;2、System V 共享内存;3、System V 信号量。（3）POSIX IPC：1、消息队列;2、共享内存;3、信号量;4、互斥量;5、条件变量;6、读写锁。前面已经了解了进程间管道通信，那么共享内存又是什么原理？
【Linux】进程间通信
热门推荐
Edward_Asia的博客
05-02 1万+
目录 1. 进程间通信 1.1. 进程间通信的目的 1.2. 如何实现进程间通信 2. 管道通信 2.1. 匿名管道 2.1.1 创建匿名管道 2.1.2 . 深入理解匿名管道 2.2. 命名管道 2.2.1. 创建命名管道 3. system V 标准进程间通信 3.1. 共享内存 3.1.1. 实现原理 3.1.2. 代码实现 3.2. 消息队列(了解) 3.2.1 实现原理 3.3. 信号量(了解) 3.3.1. 实现原理 1. 进程间通信 1.1.
android 进程间通信
anhuilee的博客
03-05 2244
管道是单向的，管道一端连接着进程的输出，进程把数据放入管道，另一端连接进程的输入，进程从管道获取数据。实现数据通信。信号类似于通知，进程通过sigaction注册接收的信号，执行响应函数。信号量类似一个计数器，用来控制多个进程对共享资源的访问， 会有一个>0的初始值，每当有进程申请使用信号量，信号量就会-1，当减到0的时候，其他进程想要访问，就必须等待，当进程执行完工作后，会释放信号量，进行+1操作。共享内存是一段物理内存，可以供给不同的进程访问。
Android 进程间通信
追梦天涯33的博客
09-12 970
Android进程间通信的几种方式以及优缺点
C++进程间通信 详解2
GIS摆渡人
05-24 3718
文章目录 一、概述二、进程间通信概念及方法1. 管道的概念2. pipe3. 管道的读写行为4. 管道缓冲区大小5. 管道优劣6. FIFO7. 共享存储映射8. mmap函数9. munmap函数10. mmap九问11. mmap父子进程间通信12. 匿名映射13. mmap无血缘关系进程间通信 3. 练习 一、概述 二、进程间通信概念及方法 Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和...
Qt QProcess 进程间通信读写数据通信
q610098308的专栏
07-17 1897
本文介绍了如何使用Qt的QProcess 进行程序开发，包括启动进程间通信、设置环境变量、通用方法；方便在日常开发中使用；
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
Python中的进程间通信
12-20
Python中的进程间通信（IPC，Inter-Process Communication）是指不同进程之间交换信息的方式。在多进程编程中，由于进程间的独立性，它们不能直接访问彼此的内存空间，因此需要通过特定的方法来协调和同步进程间的...
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
UNIX Linux实验教程 4实验四Linux进程间通信.doc
09-26
UNIX/Linux 进程间通信实验教程 UNIX/Linux 操作系统提供了一组系统调用作为用户使用其进程间通信机制的接口。进程间通信是指在多任务计算机系统中，每个进程都具有自己独立的全局变量和局部变量，子进程几乎完全...
ipcs命令 多进程间通信常用的工具
01-09
ipcs命令是用于报告Linux中进程间通信设施的状态，显示的信息包括消息列表、共享内存和信号量的信息 。 语法格式：ipcs [参数] 常用参数： -a 默认的输出信息 -m 打印出使用共享内存进行进程间通信的信息 -q ...
rt-linux下的cgroup cpu的死锁bug
最新发布
zhaoxin1989的博客
04-27 666
rt-linux下的cgroup cpu的死锁bug，rt-linux，优先级继承，cgroup，死锁，cgroup period timer，ktimer，rt-linux下的hrtimer
【Linux】基本指令（中）
输入的最佳方式是输出！✧⁺⸜(●˙▾˙●)⸝⁺✧
04-24 394
继续讲解Linux中基本指令
Linux常用指令
ya3288426755的博客
04-23 1545
最近在进行操作系统的实验，涉及到Linux系统的使用，下面总结一些常用指令，涵盖文件管理、系统信息、进程管理、用户与权限、网络工具、文本处理、压缩与归档、系统维护等核心功能。：将前一个命令的输出作为后一个命令的输入。：将命令输出保存到文件。
Linux：opencv安装
yyyyyyyyyyy_9的博客
04-24 584
如果你需要快速安装，且系统中已经包含OpenCV所需的依赖，使用APT安装最简单。如果你需要最新版本或定制安装，建议从源代码编译。如果只需要在Python中使用OpenCV，使用pip安装会更加方便。如果有其他问题，或者需要更详细的步骤，可以告诉我！
Linux进程间通信详解
"该资源为一份关于Linux进程间通信的PDF文档，由孙天泽于2006.3年撰写，主要介绍了Linux系统中的进程通信机制，适用于嵌入式Linux应用程序开发的学习与实践。文档内容包括Linux进程、内核开发、驱动程序开发以及应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值