Linux进程间通信

最新推荐文章于 2024-05-20 09:02:22 发布
最新推荐文章于 2024-05-20 09:02:22 发布
阅读量922 收藏 16
点赞数 17
分类专栏： linux 文章标签： linux unix 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53005929/article/details/125936385
版权

文章目录

🌲进程通信引论

🌴概念

进程通信是指在进程间传输数据(交换信息)。–百度百科

人与人之间的通信是什么？交换信息。进程之间的信息是什么？是数据！所以进程通信可以理解为进程之间传递数据。

IPC(InterProcess Communicatio)是进程间通信的简称。

进程通信要做的事可以理解为让多个进程看到同一块资源。

🌴目的

进程通信的目的

  • 数据传输：一个进程发送数据给另一个进程，数据量在一个字节到几M字节之间
  • 共享数据：多个进程共享同一块资源，做到这点需要内核提供同步和互斥机制。
  • 通知事件：一个进程向另一个进程发消息，比如一个进程结束时应该通知其父进程
  • 进程控制：一个进程完全控制另一个进程，如debug进程。

这些听起来都太抽象了，联系实际场景才能理解。

🌴本质

进程通信的本质就是让多个进程看到同一块资源。

这块资源常指的是内存资源，在linux下一切皆文件，所以也可以理解成文件资源。

进程通信的方式也是围绕着这一句话展开的。

🌴分类

System V和POSIX我理解为不同的标准。

image-20220720154922782

我们主要了解匿名管道、命名管道、共享内存和信号量，通信方式不同，自然通信策略也不同。

System v 和 Posix作用和区别（进程间通信IPC）_山农的博客-CSDN博客_system v

System V是Unix系统的某个版本。Posix是由IEEE和ISO开发的一套标准，两个都可以说是一种系统接口的协议。

🌲管道

🌴管道概念

管道是一种常见的进程通信工具。

Linux里的管道命令是’|'。

ls -l | grep *.txt

image-20220720162349474image-20220720164405847

🌴为什么需要管道

我们为什么需要管道，或者说两个进程间能直接传递数据吗？因为进程间不能直接通信，每个进程都是独立的，进程有自己的地址空间，如果两个进程直接传递数据，会发生写时拷贝。所以此时我们需要一个媒介，也就是这里讲的管道。借助管道我们可以实现两个进程之间的单向通信。

所以管道的作用自然也就出来了，管道的作用就是让两个进程看到同一份资源,这个资源常常指的是内存资源，也可抽象为文件资源。

image-20220720161823499

image-20220720161833247

🌴匿名管道

匿名管道用于有亲子关系的进程，常见于父子也可以用于兄弟等。

image-20220720170746651

  • 管道实现形态上是文件，但是管道本身不占用磁盘或其他外部存储的空间–摘自知乎。

  • 管道文件的内容在内存的缓冲区上，缓冲区的内容不会刷新到磁盘的文件上

    个人认为是没必要刷新到磁盘上，从内存读取的速度比从从磁盘上快的多，管道传输数据也是单向的，数据被接收的进程读取后没必要刷新到磁盘上。硬要刷新到磁盘上的话那没必要用管道…让这两个进程加载磁盘上的同一个文件不就行了。

    大佬对于管道的一些理解，从中摘录一段话：作为管道，一旦创建成功，应用除了传递数据外，能够做的只有删除操作了。

🌵创建匿名管道

匿名管道用于两个有亲缘关系的进程之间的单向通信，比如父进程写子进程读。如果有多个进程需要通信，那就建立多个管道。

🥝pipe函数

int pipe(int pipefd[2]);

传入参数为一个数组，也是输出型参数，pipefd[0]放管道的读端文件描述符，pipefd[1]放管道的写端文件描述符

image-20220720161833247

pipe函数的作用

image-20220720224446834

这里的箭头表示指针指向，而不是数据流向

pipe结合fork之后的图

image-20220720225237600

父子进程通过关闭文件描述符来实现管道的单向通信

对管道里面写入数据的操作，和对文件里写入数据的操作一样，印证了Linux下的一切皆文件。

管道是单向的，肯定是一个写一个读。所以建议写之前关闭读，读之前关闭写

既然是写之前要关闭读，读之前要关闭写，那一开始为什么还要打开读写呢，只打开读或者只打开写不就行了吗。因为父子进程拿到的文件打开方式是一样的，如果父进程只打开读那子进程也只能读，也就不能写了，我们有提到管道肯定是一个写一个读，所以父进程打开文件的方式肯定是读写（rw）。

为什么建议读之前关闭写，写之前关闭读？防止误操作。

下面的代码：父进程创建管道，父进程创建子进程，子进程在管道里每隔1s写入一次数据，父进程去读。

#include <stdio.h>
#include<unistd.h>
#include<string.h>
#include <stdlib.h>
#include<sys/types.h>
#include <sys/wait.h>
int main()
{
  int pipe_fd[2]={0};
  int ret=pipe(pipe_fd);
  if(ret<0)
  {
    perror("pipe");
    return 1;
  }
  pid_t id=fork();
  if(id==0)
  {
    //child write
    close(pipe_fd[0]);//写之前关闭读
    int cnt=5;
    const char* msg="hello world!\n";
    while(cnt--)
    {
      write(pipe_fd[1],msg,strlen(msg));
      sleep(1);
    }
    close(pipe_fd[1]);
    exit(0);
  }
  else if(id>0)
  {
    //father read 
    close(pipe_fd[1]);//读之前关闭写
    char buffer[128];
    while(1)
    {
      ssize_t num=read(pipe_fd[0],buffer,127);//读到几个字节
      if(num>0)
      {
        buffer[num]='\0';
        printf("father get the msg from child:%s\n",buffer);
      }
      else if(num==0) 
      {
        printf("piple file close,child quit\n");
        break;
      }
      else 
      {
        perror("read");
      }
    }
    close(pipe_fd[0]);
    int status=0;
    if(waitpid(id,&status,0)>0)
    {
      printf("wait success!\n");
    }
  }
  else 
  {
    perror("fork");
  }
  return 0;
}

运行效果

image-20220720232449493

随笔记录：僵尸进程的产生是因为父进程没有 wait () 子进程。,所以如果我们自己写程序的话一定要在父进程中通过 wait () 来避免僵尸进程的产生，僵尸进程的产生会导致内存泄漏。子进程僵尸，父进程没回收，父进程退出后僵尸子进程会交给Init进程，Init进程会发现并回收这个僵尸进程，如果父进程一直在运行，子进程一直僵尸，内存就泄漏了。

🌵管道读写的四种特殊情况

  1. 写端进程一直写，读端进程不读。对应的文件描述符未被关闭

如果管道满了，就要等管道有空闲空间才能继续写，也就是被读端进程读走后才能继续写。简单来说就是write阻塞

#include <stdio.h>
#include<unistd.h>
#include<string.h>
#include <stdlib.h>
#include<sys/types.h>
#include <sys/wait.h>
int main()
{
  int pipe_fd[2]={0};
  int ret=pipe(pipe_fd);
  if(ret<0)
  {
    perror("pipe");
    return 1;
  }
  pid_t id=fork();
  if(id==0)
  {
   //  child write
    close(pipe_fd[0]);
      
    const char* msg="hello world!\n";
    int cnt=1;
    while(cnt)//写端进程不断写
    {
      write(pipe_fd[1],msg,strlen(msg));
      printf("child writes the msg:%d\n",cnt);
      cnt++;
    }
      
    close(pipe_fd[1]);
    exit(0);
  }
  else if(id>0)
  {
     // father read 
    close(pipe_fd[1]);
      
    int status=0;
    if(waitpid(id,&status,0)>0)
    {
      printf("wait success!\n");
    }
  }
  else 
  {
    perror("fork");
  }
    
  return 0;
}

image-20220721093754149

  1. 写端进程不写，读端进程一直读。对应的文件描述符未被关闭

读端进程一直读，因为管道里没有数据，读端进程就被挂起了，简单来说就是read阻塞。

#include <stdio.h>
#include<unistd.h>
#include<string.h>
#include <stdlib.h>
#include<sys/types.h>
#include <sys/wait.h>
int main()
{
  int pipe_fd[2]={0};
  int ret=pipe(pipe_fd);
  if(ret<0)
  {
    perror("pipe");
    return 1;
  }
  pid_t id=fork();
  if(id==0)
  {
   //  child write
    close(pipe_fd[0]);
    while(1)//子进程不写数据
    {
      printf("pipe is NULL\n");
      sleep(1);
    }
    exit(0);
  }
  else if(id>0)
  {
     // father read 
    close(pipe_fd[1]);
     char buffer[128];
     while(1) //父进程一直在读
     { 
        ssize_t num=read(pipe_fd[0],buffer,127);
        if(num>0)
        {
          buffer[num]='\0';
          printf("father get the msg from child:%s\n",buffer);
        }
        else if(num==0) 
        {
          printf("piple file close,child quit\n");
          break;
        }
        else 
        {
          perror("read");
        }
     } 
     close(pipe_fd[0]);
    int status=0;
    if(waitpid(id,&status,0)>0)
    {
      printf("wait success!\n");
    }
  }
  else 
  {
    perror("fork");
  }

  return 0;
}

随笔记录：gdb模式下set listsize n,修改list默认显示的代码行数

image-20220721100749537

  1. 写端进程写完后被关闭，读端进程还在读。

不会出现write和read阻塞的问题，而是读端发现写端关闭后read直接返回0，然后继续执行后面的代码。

#include <stdio.h>
#include<unistd.h>
#include<string.h>
#include <stdlib.h>
#include<sys/types.h>
#include <sys/wait.h>
int main()
{
  int pipe_fd[2]={0};
  int ret=pipe(pipe_fd);
  if(ret<0)
  {
    perror("pipe");
    return 1;
  }
  pid_t id=fork();
  if(id==0)
  {
   //  child write
    close(pipe_fd[0]);
    
    int cnt=5;
    const char* msg="hello world!\n";
    while(cnt--)
    {
      write(pipe_fd[1],msg,strlen(msg));
      printf("child writes the msg:%d\n",cnt);
      sleep(1);
    }
    close(pipe_fd[1]);
    cnt=3;
    while(cnt--)
    {
      printf("pipe has closed\n");
      sleep(1);
    }
    exit(0);
  }
  else if(id>0)
  {
     // father read 
    close(pipe_fd[1]);
     char buffer[128];
     while(1) { 
        ssize_t num=read(pipe_fd[0],buffer,127);
        if(num>0)
        {
          
          buffer[num]='\0';
          printf("father get the msg from child:%s\n",buffer);
        }
        else if(num==0) 
        {
          printf("piple file close,child quit\n");
          break;
        }
        else 
        {
          perror("read");
        }
     } 
     close(pipe_fd[0]);
    int status=0;
    if(waitpid(id,&status,0)>0)
    {
      printf("wait success!\n");
    }
  }
  else 
  {
    perror("fork");
  }

  return 0;
}

image-20220721101704562

  1. 写端进程一直写，读端进程被关闭。

写的目的不就是读吗，读都被关闭了，写自然也就没有意义了。而写端还在一直写入数据，系统会干掉写端进程。

#include <stdio.h>
#include<unistd.h>
#include<string.h>
#include <stdlib.h>
#include<sys/types.h>
#include <sys/wait.h>
int main()
{
  int pipe_fd[2]={0};
  int ret=pipe(pipe_fd);
  if(ret<0)
  {
    perror("pipe");
    return 1;
  }
  pid_t id=fork();
  if(id==0)
  {
   //  child write
    close(pipe_fd[0]);
    
    int cnt=5;
    const char* msg="hello world!\n";
    while(cnt--)
    {
      write(pipe_fd[1],msg,strlen(msg));
      printf("child writes the msg:%d\n",cnt);
      sleep(1);
    }
    close(pipe_fd[1]);
    cnt=3;
    while(cnt--)
    {
      printf("pipe has closed\n");
      sleep(1);
    }
    exit(0);
  }
  else if(id>0)
  {
     // father read 
    close(pipe_fd[1]);
    close(pipe_fd[0]);
    int status=0;
    if(waitpid(id,&status,0)>0)
    {
      printf("wait success!\n");
    }
  }
  else 
  {
    perror("fork");
  }

  return 0;
}

image-20220721102500499

略微修改代码，拿到终止子进程的信号。

image-20220721104514670

🌵管道读写的特点

根据上面几种情况，我们可以窥探出管道的一些特点。

  • 管道自带同步机制

可以发现管道里有数据才会被读

管道里没有数据读端进程就会在那等

管道写满了就不会再写，就在那等待被读，这些都是同步的体现，表现为进程的运行有先后顺序。

个人理解同步的进程运行起来如同有条件约束一般，比如当管道有数据才去读，这种机制有点“束手束脚”的意思，而不是各运行各的，不会发生管你有没有数据我都去读这种情况。同步机制一般由加锁实现

  • 管道是单向通信的，肯定是一个写一个读
  • 匿名管道只能保证是具有血缘关系的进程进行通信，常常用于父子。

linux下的管道命令‘|’指的就是匿名管道，他们有同一个父进程，也就是bash进程。

  • 管道是面向字节流的（网络那块会详细阐述面向字节流）
  • 管道可以保证一定程度的数据读取的原子性（原子性：事务的不可分割性，一个操作要么被全部执行，要么全部不执行，这个操作也就是原子操作，原子操作一般通过同步机制完成，非原子操作存在线程安全问题，一般通过加锁保证操作的原子性）
  • 管道的生命周期随进程，管道也是文件，进程退出管道自然也会被关闭。

🌵管道的大小

ulimit -a

0.5KB*8=4KB

image-20220721104817801

写程序可以验证管道容量大小最大是65526个字节(64KB)

代码实现上注意写满管道前子进程不能退出了，子进程退出了的话表示读端没了，写端（父进程）就会被系统干掉，我当时没注意到这种情况打印到五千多就停了。

#include <stdio.h>
#include<string.h>
#include <stdlib.h>
#include<sys/types.h>
#include <sys/wait.h>
#include<unistd.h>
int main()
{
  int pipe_fd[2]={0};
  pipe(pipe_fd);
  pid_t id=fork();
  if(id==0)
  {
    close(pipe_fd[1]);
    while(1)//子进程不能提前退出
    {
      sleep(1);
    }

    close(pipe_fd[0]);
  }
  else
  {   
    close(pipe_fd[0]);
    char c='a';
    int cnt=1;
    while(1)
    {
      write(pipe_fd[1],&c,1);
      printf("%d\n",cnt);
      cnt++;
    }
    close(pipe_fd[1]);
    waitpid(id,NULL,0);

  }
  return 0;
}

image-20220721153501198

为什么ulimits -a打印的是4KB,我们测试的时候是64KB呢？4KB是内核管道的大小，由内核设定，64KB可以理解为管道大小的最大值，即容量（可以类比vector的size和capacity）

参考资料👉Linux管道的容量大小及管道的数据结构

随笔记录：取消43,70行的注释

image-20220721111710687

:43,70 s/^g 可以注释43-70行

🌴命名管道

匿名管道只能用于两个有亲缘关系的进程通信，如果没有亲缘关系又要通信的话，此时就需要命名管道了。

image-20220721162609034

🌵创建命名管道

mkfifo命令

image-20220721154338535

🥝mkfifo函数

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

文件路径具有唯一性，所以可以让两个进程看到同一份资源。

image-20220721155720841

在当前目录下创建一个管道文件的例子。

#include<stdio.h>
#include<sys/types.h>
#include <sys/stat.h>

int main()
{
  if(mkfifo("./myfifo",0644)<0)
  {
    perror("mkfifo");
    return 1;
  }
  return 0;
}

运行效果

image-20220721160915504

🌵server和client的小demo

server，服务端读。

client，客户端写。

在服务端创建一个管道文件，客户端打开文件后进行写入，服务端再打开文件读取数据就实现了服务端和客户端两个进程的通信。

启动的时候是先启动服务端，因为要创建管道文件。

server.c

#include <stdio.h>
#include<unistd.h>
#include <sys/types.h>
#include<sys/stat.h>
#include <fcntl.h>

int main()
{
  if(mkfifo("./myfifo",0644)<0)
  {
    perror("mkfifo");
    return 1;
  }
  int fd=open("myfifo",O_RDWR);
  if(fd<0)
  {
    perror("open");
    return 2;
  }
  while(1)
  {
    char buf[128];
    ssize_t num=read(fd,buf,sizeof(buf)-1);
    buf[num]='\0';
    printf("server has got the msg:%s\n",buf);
    sleep(1);
  }
  return 0;
}

client.c

#include <stdio.h>
#include<unistd.h>
#include <sys/types.h>
#include<sys/stat.h>
#include <fcntl.h>
#include <string.h>

int main()
{
  int fd=open("myfifo",O_RDWR);
  if(fd<0)
  {
    perror("open");
    return 1;
  }
  while(1)
  {
    const char* msg="hello world\n";
    write(fd,msg, strlen(msg));
    printf("client has wrote the msg!\n\n");
    sleep(1);
  }
  return 0;

}

Makefile

.PHONY:all
all:client server 

client:client.c
	gcc -o $@ $^

server:server.c
	gcc -o $@ $^

.PHONY:clean
clean:
	rm -f client server

运行效果

image-20220721171251655

命名管道还有很多用途。比如进程遥控，还可以结合进程替换传递命令，等等。

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

  • 匿名管道用于有亲缘关系的进程，命名管道用于任意两个进程。
  • 匿名管道的打开交给了pipe函数，pipe函数会创建并打开。命名管道的创建交给了mkfifo函数，管道的打开交给了open。
  • 两者唯一区别就是打开和创建方式不同，创建和打开完成后，两者其实都是一样的。（因为创建和打开的工作就是让两个进程看到一块资源，怎么操作资源就是文件操作的事了）

🌲System V IPC

我的理解System V就是一个标准,这个标准下有几种通信方式，如共享内存，信号量等。

🌴共享内存

共享内存的原理：多个进程的页表映射到一块物理内存。

image-20220722091711415

这个过程可以简单概括为：OS申请一块物理内存，将该内存映射进对应进程的共享区中，再将映射之后的虚拟地址给用户。此时两个进程就看到了同一块资源，就可以对这块资源实施操作，自然也就实现通信了。

那有这么多的共享内存，我们怎么保证多个进程看到的是同一块共享内存呢，通过一个key值，这个key值保证了这块空间的唯一性，多个进程可以通过一个传入路径的函数生成同一个key值，那多个进程就能看到同一块空间了。

那自然引申出了一个问题：OS提供了这么多的共享内存，那OS要不要管理这么多的共享内存呢？答案是肯定的。

OS要管理一个东西，那自然是那六个字了：先描述再组织。

内核里描述共享内存的是一个结构体，即struct shmid_ds,里面存着这块空间的属性，比如空间的大小，最后的修改时间，谁创建的等等，shmid_ds这个结构体里面还有一个名为shm_perm的结构体，类型是struct ipc_perm，里面存放了一个key,用来保证这块空间的唯一性。

shm：share memory

image-20220722093028545

image-20220722094840195

🌵ftok函数生成key值

ftok函数生成key值，key值的类型key_t，也就是int

image-20220722101603743

key_t ftok(const char *pathname, int proj_id);

image-20220722095837793

这两个参数可以随便填， 反正目的是生成一个key值，只要第二个参数别传0就行（按文档说的来呗）

比如两个进程传入相同的参数就可以得到同一个key值，就可以看到同一块资源（对资源的操作不是根据key来的，OS给了一个标识符shmid，对资源的操作通过shmid，key只标识空间的唯一性）。

🌵shmget函数创建共享内存

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

创建一块共享内存，传入参数的key用来保证这块空间的唯一性，size是大小，shmflg是怎么创建这块空间，即选项。创建成功返回这块空间的标识符，创建失败返回-1，注意这块空间的标识符不是key，我们不通过key操作共享内存。

image-20220722094309099

关于函数的第三个参数shmflg,创建共享内存时建议用IPC_CREAT|IPC_EXCL，判断共享区存不存在的依据是key值是否重复。

IPC_CREAT|IPC_EXCL|0644表示创建一个权限为644的共享内存，如果这块共享内存已经存在则创建失败。

单独用IPC_CREAT表示获取已存在的共享内存标识符。比如父进程创建好了共享内存，那子进程就只需要获取这个标识符就够了。

关于共享内存创建的大小，建议是4KB，因为OS申请的大小会是4KB的倍数，比如申请4097个字节，实际分配到的是8KB，只不过我们只能用4KB.

关于返回值，创建成功返回的是这块空间的标识符shmid，需要与key区分开来。（文件的inode唯一标识文件，但是我们通过fd对文件进行操作，类比过来这里的shmid相当于fd)

🌵shmat函数挂载进程

之前创建了共享内存，但是创建的共享内存和进程还没连接上，所以此时需要挂载进程，或者说关联进程。

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

image-20220722103328930

第一个参数传共享内存标识符，第二个传NULL（表示系统自动分配地址），第三个传0，表示以读写的方式连接此段。（除非用系统提供的宏指定以只读方式连接，否则默认以读写的方式连接）。

👉shmat 函数的使用

返回值

成功就返回这块空间的实际地址（当然是虚拟的），失败返回-1.我们拿到了地址自然就可以对这块空间进行写入了。

image-20220722103850192

🌵shmdt函数去关联（shmat的反义词）

int shmdt(const void *shmaddr);

进程调用这个函数，传入这块共享内存的地址，也就是shmat函数的返回值，即可将这个进程与这块共享内存去关联。

我猜dt是delete attach的意思。

🌵shmctl函数释放共享内存

共享内存的生命周期是随内核的，而不是随进程的，所以需要我们手动释放。

释放这块内存可以用指令，也可以进程退出前调用函数，再或者OS重启

这个函数不止可以释放共享内存，但是常用来来释放共享内存。

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

image-20220722102345608

创建成功返回0，创建失败返回-1.

删除共享内存这种操作对应的cmd是IPC_RMID。

image-20220722102741035

第三个参数在别的操作里作为输出型参数。

综上所述，shmctl(shmid,IPC_RMID,NULL)这样就可以释放shmid指向的那块共享空间。

🌵ipcs命令

image-20220722153809401

ipcrm -m shmid可以删掉shmid这块共享内存,或者说释放这块共享内存。-m命令表示如果没有进程绑定时就删除这块共享内存。

Linux 命令（52）—— ipcrm 命令_

🌵server和client的小demo

大体思路如下

image-20220722111350075

comm.h

#pragma once 
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define PATH "/home/ck/lesson18/shm_pipe"
#define SIZE 4097

server.c

#include"comm.h"

int main()
{
  //生成key值
  key_t key=ftok(PATH,1); 
   //创建共享牛才能
  int shmid=shmget(key,4097,IPC_CREAT|IPC_EXCL|0644);
  if(shmid<0)
  {
    perror("shmget");
    return 1;
  }
   //与进程绑定并拿到地址
  char* start=(char*)shmat(shmid,NULL,0);
  if(start==(char*)-1)
  {
    perror("shmat");
    return 2;
  }
  //TODO 每隔一秒读一次
  int cnt=0;
  while(1)
  {
    printf("%s\n",start);
    cnt++;
    sleep(1);
  }

//与这块共享内存段去关联
  shmdt(start);
//释放掉这块内存
  shmctl(shmid,IPC_RMID,NULL);


  return 0;
}

client.c

#include "comm.h"

int main()
{
  //生成key值
  key_t key=ftok(PATH,1); 
  //获取这块内存的shmid
  int shmid=shmget(key,4097,IPC_CREAT);
  if(shmid<0)
  {
    perror("shmget");
    return 1;
  }
  //绑定这块内存并拿到地址
  char* start=(char*)shmat(shmid,NULL,0);
  if(start==(char*)-1)
  {
    perror("shmat");
    return 2;
  }
  //TODO 每隔1s写入一个字符
  int cnt=0;
  while(1)
  {
    start[cnt]='A'+cnt;
    cnt++;
    start[cnt]='\0';
    sleep(1);
  }
  //与这块内存去关联
  shmdt(start);

  return 0;
}

运行操作和效果

先运行server程序，创建共享内存，发现server有一段时间空读，因为此时client程序还没运行起来，两个程序都运行起来后用ipcs查看这块共享内存的信息，之后先结束client进程，再用ipcs -m命令发现这块内存下挂载的进程数减1，再结束server进程，再用ipcs命令观察，发现共享内存依旧存在，原因是程序在读写时被信号终止了，没有运行到去关联和释放共享内存的代码。

Markdown博客演示47

从运行效果也可以看出来，共享内存没有管道那样的同步机制，注意client运行之前的server进程一直都是空读，这两个程序看起来就像各运行各的。

🌵共享内存的特点

  • 共享内存的生命周期随系统，或者说随内核
  • 共享内存不提供任何同步与互斥的操作，双方彼此独立
  • 共享内存时所有进程间通信中，速度最快的（比如管道和消息队列数据都要拷贝四次，而共享内存数据只需要拷贝两次）
  • 关于共享内存的大小，OS分配共享内存是一页一页分配的，一页是4KB，所以我们要4097个字节拿到的实际是8KB，只不过我们只能用4KB

🌵共享内存与管道的对比

两个角度，一个是速度方面，一个是数据同步上。

数据同步方面，管道是有数据同步和互斥方面的一些机制的，但是共享内存没有。要有的话就得自己控制了。

速度方面，共享内存的数据只需要拷贝两次，管道的数据需要拷贝四次，所以共享内存的速度更快。

下面画的两幅图是我结合网上的说法和自己的理解画的，不一定对。

image-20220722163100533

image-20220722163247940

待了解：mmap,现在简单理解为一种将文件映射到进程地址空间的方式，效果上也是减少拷贝（数据量很大时其实减少一次拷贝对于性能都会有不错的提升）

认真分析mmap：是什么 为什么 怎么用 - 胡潇 - 博客园 (cnblogs.com)

🌴消息队列

没学。

查阅了些许资料，意思是消息队列和管道不同，管道中的数据是按字节流来的，而消息队列里的“消息”是具有结构的。通信的过程是通过key建立链接再发送“消息”

Linux进程间通信——消息队列 - 知乎 (zhihu.com)

🌴信号量

  • 进程看到的同一份资源，我们叫做临界资源。进程不是所有的代码都在访问资源，只是部分代码在访问，造成数据不一致的正是这小部分代码，我们称之为临界区

  • 为了避免数据不一致，需要对临界资源进行某种保护，即互斥，互斥是一部分空间任何时候有且只能有一个进程在访问，可以通过锁来实现。简而言之，我们通过对临界区进行加锁和解锁完成互斥操作来保护临界资源。

  • 信号量的本质是一个具有原子性的计数器，用来描述可用资源的数目，可以保护临界资源的安全。

  • 为什么信号量可以保护临界资源？信号量的计数器是结合了锁的，具有互斥的性质，由于锁的缘故这个操作是有原子性的，解决了同一块资源可能会被多个进程同时使用导致的数据不一致的问题。

//写一段伪代码  只是大概描述这个过程，信号量的实现肯定不是这么简单
lock()
if(count<=0)//count就是计数器
{
    pause;
}
else
{
    count--;//“预定了这块资源”
}
unlock()
//从这可以知道，只要“预定”到了资源，要用的时候就肯定有
  • PV操作（原语），P操作申请信号量（预定一块资源），那我们要用时候肯定有,V可以理解为用完了释放一个资源（计数器count++）

原语就是一段不可被中止的程序指令集合。就是只要运行了，肯定就要运行完。原子性也是一个道理，要做就做完，不然就一点都不做。

  • 消息量在内核里的描述也是一个结构体，系统给了许多相关的接口（有兴趣可以查阅相关资料）。信号量本身就是一个临界资源，因为每个进程申请信号量的前提是他们都得看到同一个信号量。

我当时理解信号量时的一个疑惑，在这记录一下：为什么信号量没有数据交换也是通信的一种方式

喜欢乙醇的四氯化碳
关注
  • 17
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 15
    评论
专栏目录
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
linux进程id做key,Linux系统编程之进程间通信方式：消息队列
weixin_42499004的博客
04-30 201
原标题：Linux系统编程之进程间通信方式：消息队列消息队列提供了一种在两个不相关的进程之间传递数据的简单高效的方法，其特点如下：1)消息队列可以实现消息的随机查询。消息不一定要以先进先出的次序读取，编程时可以按消息的类型读取。2)消息队列允许一个或多个进程向它写入或者读取消息。3)与无名管道、命名管道一样，从消息队列中读出消息，消息队列中对应的数据都会被删除。4)每个消息队列都有消息队列标识符，...
Linux 进程间通信
人生一世 草木一秋
08-12 2442
Linux进程通信继承了传统的UNIX进程间通信方式，包括无名管道、有名管道以及信号；还有System V进程间通信（IPC），包括System V消息队列、System V信号量以及System V共享内存；套接字。
Linux进程间通信【命名管道】
热门推荐
北 海的博客
06-07 1万+
命名管道通信属于IPC的其中一种方式，作为管道家族，命名管道的特点就是自带同步与互斥机制、数据单向流通，与匿名管道不同的是：命名管道有自己的名字，因此可以被没有血缘关系的进程看到，意味着命名管道可以实现毫不相干的两个独立进程间通信
Linux进程间通信详解（最全）
qq_40989769的博客
03-08 2175
进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享内存、Socket（套接字）等。其中 Socket和支持不同主机上的两个进程IPC。
浅谈Linux进程间通信方式及优缺点
01-11
有名管道也是一种半双工的通信方式,但是它允许无亲缘关系进程间的通信。 2)信号量 信号量是一个计数器,可以用来控制多个线程对共享资源的访问.,它不是用于交换大批数据,而用于多线程之间的同步.它常作为一种锁机制...
linux-linux进程间通信方式汇总.zip
02-26
linux linux_linux进程间通信方式汇总
linux---进程通信
m0_74979625的博客
05-17 549
提示：以下是本篇文章正文内容，下面案例可供参考。
Linux 三十六章
一怀明月的博客
05-17 985
信号量 sem_init sem_destroy sem_wait sem_post 基于环形队列的CP问题 环形队列的生产者消费者模型 线程池 localtime时间戳转化 mkdir系统调用 bind绑定成员函数 懒汉饿汉单例模式 懒汉模式： 饿汉模式： 懒汉和饿汉相同点： 线程池源码实现
Linux动静态库
2301_80163789的博客
05-14 625
在程序翻译的链接阶段，其实就是把一堆.o文件链接在一起形成.exe文件。如果一个程序中需要链接很多个.o文件，那么这些.o文件就需要被打包才方便管理，**库文件本质就是把.o文件打包。**库文件是一种提高开发效率的手段。对于静态库，使用静态库形成可执行程序后，静态库被加载到了可执行程序的代码里，不需要让系统知道静态库在哪里；但对于动态库，由于动态库不加载到可执行程序里，而是动态加载到内存中，所以使用动态库要告诉系统动态库在哪（因为是系统来加载动态库）。动态库在编译时代码不会被复制到可执行文件中，而是。
【Linux】Centos7安装Redis
m0_72166275的博客
05-17 312
Reid 官网下载 Redis 7.2。
【linux】linux中免交互命令expect原理与应用实战
最新发布
景天科技苑
05-20 1429
Expect 是基于 Tcl 的相对简单的一个免费的脚本编程工具语言，用来实现 自动和交互式任务程序进行通信，无需人的手工干预。比如 SSH、FTP 等，这些 程序正常情况都需要手工与它们进行交互，而使用 Expect 就可以模拟人手工交 互的过程，实现自动的和远程的程序交互，从而达到自动化运维的目的。
操作系统 实验13 批处理操作接口3：引用与命令替换
m0_63093530的博客
05-14 154
结果：第一个和第三个命令是错的，第二个和第四个命令是对的。echo "这是命令替换形式1...$date1"echo "$sv ++++加上另一些字符！2、输出字符串“China's panda”命令：echo China\'s panda。6、将命令date执行结果赋予变量date1。7、将命令date执行结果赋予变量date2。1、输出字符串“$Dollar”命令：echo \$Dollar。命令：date2=$(date)命令：date1=`date`
从零开始学习Linux（8）----自定义shell
lys20221113242的博客
05-14 243
shell从用户读入字符串“ls”，shell建立一个新的进程，然后在那个进程中运行ls程序并等待那个进程结束。然后shell读取新的一行输入，建立一个新的进程，在这个进程中运行程序，并等待这个进程结束。5. 父进程等待子进程退出（wait）3. 建立一个子进程（fork）4. 替换子进程（execvp）
linux中查找某个文件或文件夹
DN金猿的博客
05-18 238
locate命令将会在整个系统中搜索文件和文件夹，并通过正则表达式匹配以"/folder_name"结尾的路径。这将会在指定的路径（/path/to/search）中递归地列出所有文件和文件夹，并使用grep命令匹配以"/folder_name"结尾的行。该命令将会在指定的路径（/path/to/search）中查找名称为"folder_name"的文件夹。此方法与第2种方法类似，但使用了find命令来递归搜索文件夹，并使用grep命令来匹配以"/folder_name"结尾的行。
Linux：网络管理命令之ss
hhd1988的专栏
05-17 810
Linux：网络管理命令之ss

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

喜欢乙醇的四氯化碳

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

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

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

打赏作者

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

抵扣说明：

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

余额充值