进程间通信 "共享内存" 与 “信号量”的使用

最新推荐文章于 2024-03-01 19:33:38 发布
最新推荐文章于 2024-03-01 19:33:38 发布
阅读量991 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Linux C/C++语言 文章标签： fork 共享内存 信号量
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u011866460/article/details/46754591
本文介绍了如何使用fork函数创建多进程，并通过实例演示了父子进程的执行流程与数据隔离特性。进一步探讨了共享内存和信号量在进程间通信中的应用。

使用fork创建多进程

首先对fork函数进行简单介绍：

fork()函数不同于普通函数，主要体现在其返回值上，返回值
- 小于0：fork()执行失败
- 等于0：子进程, 在子进程中fork返回的是0
- 大于0：父进程, 在父进程中fork返回的是创建的子进程的pid
用程序来详细解释一下：

pid_t ret;  // fork 返回值类型
if ((ret = fork()) < 0)
{
    fprintf(stderr,"fork fail. ErrNo[%d],ErrMsg[%s]\n",errno,strerror(errno));
}
else if (ret > 0)
{
    // 该花括号内的所有语句属于父进程，父进程执行这些语句
    fprintf(stdout,"** parent process run. pid:[%6d], ppid:[%6d],ret:[%6d]**\n",getpid(),getppid(),ret);
}
else
{
    // 该花括号内的所有语句属于子进程，子进程执行这些语句
    fprintf(stdout,"** child process run. pid:[%6d], ppid:[%6d],ret:[%6d]  **\n",getpid(),getppid(),ret);
}

// 父子进程都会执行的一句
printf("========== last line.  pid:[%6d], ppid:[%6d],ret:[%6d] ==========\n",getpid(),getppid(),ret);

对fork函数的解释：
1. fork函数理解为，在执行的瞬间将程序进行了拷贝，原本的可称为父进程，拷贝出来的是子进程。
2. 这种拷贝可理解为包括寄存器等所有内容的拷贝，自然也包括了程序计数器pc，如此子进程和父进程都从fork函数之后的地址继续往下执行。
3. 实质上，父子进程拥有这相同的代码，但是为了控制父进程执行父进程的代码，子进程执行子进程的。这是fork()函数在父子进程中不同的返回值就派上了用场。
4. 通过 if 判断，控制父进程执行父进程的执行体，子进程执行子进程的。也就是说父子进程的代码段是相同的。每个人都有一个副本，仅仅是执行了自己要执行的部分，对方的自己有却没有执行。
5. 再说程序的数据段，同样也是各自有着一个副本，变量的名称和结构相同，但是当父进程对其进行修改的话，也只有父进程可见，子进程不可见。原因就在于子进程有着自己的副本，自己没有改，就不会有变化。

通过下面的程序可以验证：

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

#define SHM_SIZE 4096

int main()
{
    char buf[30];
    memset(buf, 0x00, 30);
    memcpy(buf, "default value", 13);

    pid_t ret;
    if ((ret = fork()) < 0)
    {
        printf("fork fail. ErrNo[%d],ErrMsg[%s]\n",errno,strerror(errno));
    }
    else if (ret > 0) // 父进程
    {

        // 读写操作
        memset(buf, 0x00, 30);
        memcpy(buf, "hello world! can you read me?", 29);
        // 验证写入正常
        printf("parent read SHM [%s]\n",buf);
        // 写完等5秒,让子进程读取,否则程序就结束了,也就执行最后的删除共享内存操作了
        sleep(5);

    }
    else // 子进程
    {
        printf("child sleep(3), wait for parent  to write\n");
        sleep(3);

        // 读写操作
        printf("child read SHM [%s]\n",buf);
    }

    // 该句父子进程都会执行，因为没有 if 判断返回值，父子进程都可就的同时也都执行了它
    printf("pid = [%5d] ppid = [%5d] ret = [%5d], last line read SHM [%s]\n",getpid(),getppid(),ret,buf);

    return 0;
}

执行结果为：

parent read SHM [hello world! can you read me?]
child sleep(3), wait for parent  to write
child read SHM [default value]
pid = [16922] ppid = [16921] ret = [    0], last line read SHM [default value]
pid = [16921] ppid = [10783] ret = [16922], last line read SHM [hello world! can you read me?]
  • ret = 0 是子进程的执行结果，它感知不到父进程的修改
  • ret != 0 是父进程，他可以看到自己的修改
  • 总之，两两不相知！

响应召唤，进程间通信就横空出世了

为了让进程间可以共享数据，方法甚多，比如：通过文件，数据库等，典型的进程间通（IPC）信应当是：消息队列、信号量和共享内存。
这里我说说共享内存，其余用到了在补充，看程序如下(类似与上面的例子)：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

#define SHM_SIZE 4096

int main()
{
    // 1.创建共享内存，获取共享内存的标识符
    int shmid;       //共享内存标识符
    shmid_ds * buf;  //共享存储段基本信息结构体
    buf = NULL;
    shmid = shmget(IPC_PRIVATE, SHM_SIZE, 0666|O_CREAT);

    pid_t ret;
    if ((ret = fork()) < 0)
    {
        printf("fork fail. ErrNo[%d],ErrMsg[%s]\n",errno,strerror(errno));
    }
    else if (ret > 0) // 父进程
    {
        void *parent_shm = NULL; // 共享内存的首地址
        // 2.连接共享内存,第二个0代表由内核选择可用地址,是推荐用法
        parent_shm = shmat(shmid, 0, 0);
        if ((void*)-1 == parent_shm)
        {
            printf("parent shmat fail. ErrNo[%d],ErrMsg[%s]\n",errno, strerror(errno));
        }

        // 读写操作
        memcpy((char*)parent_shm, "hello world! can you read me?", 29);

        // 3.断开共享内存
        if (-1 == shmdt(parent_shm))
        {
            printf("parent shmdt fail. ErrNo[%d],ErrMsg[%s]\n",errno, strerror(errno));
        }

        // 写完等5秒,让子进程读取,否则程序就结束了,也就执行最后的删除共享内存操作了
        sleep(5);

    }
    else // 子进程
    {
        printf("child sleep(3), wait for parent  to write\n");
        sleep(3);

        void *child_shm = NULL; // 共享内存的首地址
        // 2.连接共享内存,第二个0代表由内核选择可用地址,是推荐用法
        child_shm = shmat(shmid, 0, SHM_RDONLY);
        if ((void*)-1 == child_shm)
        {
            printf("child shmat fail. ErrNo[%d],ErrMsg[%s]\n",errno, strerror(errno));
        }

        // 读写操作
        printf("child read SHM [%s]\n",(char*)child_shm);

        // 3.断开共享内存
        if (-1 == shmdt(child_shm))
        {
            printf("child shmdt fail. ErrNo[%d],ErrMsg[%s]\n",errno, strerror(errno));
        }
        exit(0);  // 这是一个控制让子进程不执行后面代码的方法，结束掉他
    }

    // 此处没有了上面的程序中的输出语句，首先子进程已经执行不到这里了，其次，无论父子进程执行到这里都读取不到数据，因为他们都调用了shmdt断开了和共享内存的连接。如果没有断开，当然是可读的。同时还需要把parent_shm与child_shm的指针声明放到全局main函数区

    // 4.删除共享内存
    if (shmctl(shmid, IPC_RMID, buf) != 0)
    {
         printf("main shmctl IPC_RMID fail. ErrNo[%d],ErrMsg[%s]\n",errno, strerror(errno));
    }
}

执行结果：

child sleep(3), wait for parent  to write
child read SHM [hello world! can you read me?]

总结：子进程读到父进程所写的数据了。

共享内存函数总结：
① 获取共享内存表示符
- int shmget(ket_t key, size_t size, int flag);
② 连接共享内存
- void *shmat(int shmid, const void *addr, int flag);
③ 断开共享内存的连接
- int shmdt(const void *addr);
④ 共享内存的控制, 包括修改读写权限, 删除等
- int shmctl(int shmid, int cmd, struct shmid_ds *buf);
总结：共享内存的使用还是挺简单的，只需要知道这四个函数，以及他们的返回值和参数就够了，具体函数解释可以man一下，或者《UNIX环境高级编程》，我就不做搬运工了。

没错，这样是有问题的，进程间通信不提供同步机制 —- 信号量 出场

上面的方法通过使用sleep()简单进行了进程间同步，这在真是环境中是不可用的，那么这里就需要 信号量 来进行同步了(同步，就是说一个进程在写的时候另一进程不能去读或者写，否则最总出来的结果有问题，数据不正确，不可用)。

概念：信号量本身是一个计数器，用于为多个进程提供对共享数据对象的访问。所以它与管道，消息队列，共享内存本质上是有区别的（一个是控制访问的，其余是进行数据共享的）。

看程序：

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <iostream>
#include <semaphore.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <fcntl.h>

using namespace std;

volatile int flag = 1;

const char SEM_MUTEX[10] = "sem_mutex"; 

int main()
{
  sem_t *sem_t_mutex;

  // 1.创建信号量，初始值为1
  sem_t_mutex = sem_open(SEM_MUTEX, O_CREAT, 0777, 1);
  if (SEM_FAILED == sem_t_mutex) {
      printf("mutex 创建失败");
  }

  pid_t ret;

  if ( (ret=fork()) < 0 )
  {
      fprintf(stderr,"fork fail. ErrNo[%d],ErrMsg[%s]\n",errno,strerror(errno));
  }
  else if ( 0==ret )   // 子进程
  {
      printf("clild create ok\n");
      // 2. 加锁，实质上就是给信号量做减一操作，若本身已经为0，程序阻塞到这里，等待
      if (sem_wait(sem_t_mutex)!=0)   // 加锁
          printf("lock fail\n");
      int i = 0;
      while(i < 4)
      {
          i++;
          printf("clild: run in while\n");
          sleep(1);
      }

      // 3.解锁，实质上就是给信号量做加一操作，加一后，那些等待的，处于阻塞的进程就能运行了
      if (sem_post(sem_t_mutex)!=0)
          printf("unlock fail\n");
      exit(0);  //  可以结束掉子进程,那么程序将不会再运行最后一行的printf,原因在于:fork之后的代码父子进程都可见都会执行,通过if可以控制父子进程进行执行不同的内容,原理在于fork不同于其他函数他返回两个值,给父进程返回的是子进程的pid,给子进程自己返回的是0,失败返回 -1,于是当在if中碰到exit自然子进程就结束了
  }
  else  //  父进程
  {
      sleep(1);
      printf("parent can run ok\n");
      // 2. 加锁，实质上就是给信号量做减一操作，若本身已经为0，程序阻塞到这里，等待
      if (sem_wait(sem_t_mutex)!=0)
          printf("parent lock fai\n");
      int j = 0;
      while(j<10)
      {
          j++;
          fprintf(stdout,"** parent process run. pid:[%6d], ppid:[%6d],ret:[%6d]  **\n",getpid(),getppid(),ret);
          sleep(1);
      }
     // 3.解锁，实质上就是给信号量做加一操作，加一后，那些等待的，处于阻塞的进程就能运行了
     sem_post(sem_t_mutex);
  }
  // 4. 关闭，若没有该步骤，程序结束就会执行关闭
  sem_close(sem_t_mutex);
  // 5. 销毁，** 特别重要 ** ，不销毁，信号量的值会一直保留，比如信号量在退出时是 1 ，下次执行依旧会存在，导致二次运行程序的时候出错。
  sem_unlink(SEM_MUTEX);
  printf("========== last line.  pid:[%6d], ppid:[%6d],ret:[%6d] ==========\n",getpid(),getppid(),ret);
}

运行结果：

clild create ok
clild: run in while
parent can run ok
clild: run in while
clild: run in while
clild: run in while
** parent process run. pid:[ 27104], ppid:[ 26251],ret:[ 27105]  **
** parent process run. pid:[ 27104], ppid:[ 26251],ret:[ 27105]  **
** parent process run. pid:[ 27104], ppid:[ 26251],ret:[ 27105]  **
** parent process run. pid:[ 27104], ppid:[ 26251],ret:[ 27105]  **
** parent process run. pid:[ 27104], ppid:[ 26251],ret:[ 27105]  **
** parent process run. pid:[ 27104], ppid:[ 26251],ret:[ 27105]  **
** parent process run. pid:[ 27104], ppid:[ 26251],ret:[ 27105]  **
** parent process run. pid:[ 27104], ppid:[ 26251],ret:[ 27105]  **
** parent process run. pid:[ 27104], ppid:[ 26251],ret:[ 27105]  **
** parent process run. pid:[ 27104], ppid:[ 26251],ret:[ 27105]  **
========== last line.  pid:[ 27104], ppid:[ 26251],ret:[ 27105] ==========

结论：父进程sleep(1) 使得子进程获得了锁，于是父进程在sleep(1)后阻塞，知道子进程运行结束，释放锁，父进程才能执行，表现出来就是，子进程先执行，父进程后执行。如果没有锁，可以肯定，是乱序执行的，比如，注释掉加锁的相关行，执行结果如下：

clild create ok
clild: run in while
** parent process run. pid:[ 27525], ppid:[ 26251],ret:[ 27526]  **
clild: run in while
** parent process run. pid:[ 27525], ppid:[ 26251],ret:[ 27526]  **
clild: run in while
** parent process run. pid:[ 27525], ppid:[ 26251],ret:[ 27526]  **
clild: run in while
** parent process run. pid:[ 27525], ppid:[ 26251],ret:[ 27526]  **
** parent process run. pid:[ 27525], ppid:[ 26251],ret:[ 27526]  **
** parent process run. pid:[ 27525], ppid:[ 26251],ret:[ 27526]  **
** parent process run. pid:[ 27525], ppid:[ 26251],ret:[ 27526]  **
** parent process run. pid:[ 27525], ppid:[ 26251],ret:[ 27526]  **
** parent process run. pid:[ 27525], ppid:[ 26251],ret:[ 27526]  **
========== last line.  pid:[ 27525], ppid:[ 26251],ret:[ 27526] ==========

信号量这样用才好

程序如下：

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>

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

#include <iostream>

#include <semaphore.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <fcntl.h>

using namespace std;

volatile int flag = 1;

const char SEM_MUTEX[10] = "sem_mutex"; 

/*  多进程的基本用法  */
int main()
{
  sem_t *sem_t_mutex=NULL;

  sem_t_mutex = sem_open(SEM_MUTEX, O_CREAT, 0777, 0);
  if (SEM_FAILED == sem_t_mutex) {
      printf("mutex 创建失败");
  }

  pid_t ret;

  if ( (ret=fork()) < 0 )
  {
      fprintf(stderr,"fork fail. ErrNo[%d],ErrMsg[%s]\n",errno,strerror(errno));
  }
  else if ( 0==ret )   // 子进程
  {
      printf("clild create ok\n");
      if (sem_wait(sem_t_mutex)!=0)   // 加锁
          printf("lock fail\n");
      int i = 0;
      while(i < 4)
      {
          i++;
          printf("clild: run in while\n");
          sleep(1);
      }

      exit(0);  //  可以结束掉子进程,那么程序将不会再运行最后一行的printf,原因在于:fork之后的代码父子进程都可见都会执行,通过if可以控制父子进程进行执行不同的内容,原理在于fork不同于其他函数他返回两个值,给父进程返回的是子进程的pid,给子进程自己返回的是0,失败返回 -1,于是当在if中碰到exit自然子进程就结束了
  }
  else  //  父进程
  {
      printf("parent can run ok\n");

      int j = 0;
      while(j<10)
      {
          j++;
          fprintf(stdout,"** parent process run. pid:[%6d], ppid:[%6d],ret:[%6d]  **\n",getpid(),getppid(),ret);
          sleep(1);
      }
      // 只有等到父进程执行完了，释放了锁，子进程才能加锁成功，才能运行
      if (sem_post(sem_t_mutex)!=0)
          printf("unlock fail\n");
      // 等子进程执行完了再运行最后那几行
      sleep(5);
  }

  sem_close(sem_t_mutex);
  sem_unlink(SEM_MUTEX);
  printf("========== last line.  pid:[%6d], ppid:[%6d],ret:[%6d] ==========\n",getpid(),getppid(),ret);
}

运行结果：

parent can run ok
** parent process run. pid:[ 28037], ppid:[ 26251],ret:[ 28038]  **
clild create ok
** parent process run. pid:[ 28037], ppid:[ 26251],ret:[ 28038]  **
** parent process run. pid:[ 28037], ppid:[ 26251],ret:[ 28038]  **
** parent process run. pid:[ 28037], ppid:[ 26251],ret:[ 28038]  **
** parent process run. pid:[ 28037], ppid:[ 26251],ret:[ 28038]  **
** parent process run. pid:[ 28037], ppid:[ 26251],ret:[ 28038]  **
** parent process run. pid:[ 28037], ppid:[ 26251],ret:[ 28038]  **
** parent process run. pid:[ 28037], ppid:[ 26251],ret:[ 28038]  **
** parent process run. pid:[ 28037], ppid:[ 26251],ret:[ 28038]  **
** parent process run. pid:[ 28037], ppid:[ 26251],ret:[ 28038]  **
clild: run in while
clild: run in while
clild: run in while
clild: run in while
========== last line.  pid:[ 28037], ppid:[ 26251],ret:[ 28038] ==========

结论：

这里并没有为了让一个进程先运行，而让另一个sleep等待；而是采用了谁想先执行，就让对方直接去获取锁。注意，该处初始化锁的时候默认值是0，那么自然获取锁的时候就阻塞了。而先运行的进程在运行结束的时候释放锁，如此，当它运行完释放锁后，阻塞的进程就能执行了。

有了共享内存、信号量；这样就能二者结合正式使用了

这下其实就简单了，也不用多说了，也就不写了。

注：本文的目的就是直接教会怎么用共享内存

进程间通信 共享内存 + 信号量
快乐星球
12-19 1002
共享内存是最快的 IPC形式，，一旦这样的内存映射到进程的地址空间，这些空间的数据将不再涉及内核。 ipcs -m 查看共享内存 System V共享内存 共享内存的步骤： 1 创建/打开共享内存对象ftok(“存在的路径”，任意整数)； eg: key_t ftok(".",0x02) 可以写成一个函数 只要参数相同，一定是共享内存 2 附加到共享内存对象上（shmat->...
进程间通信（IPC）：共享内存（shared memory）和信号量（semaphore)
Rain土的博客
08-12 6327
共享内存和信号量共享内存使用共享内存通信的一般步骤创建共享内存共享内存的映射和解除映射共享内存操作函数示例代码信号量多任务编程中互斥和同步的概念信号量(Semaphore)信号量的操作相关函数函数使用示例信号量配合共享内存使用 共享内存 ???????????????????? 共享内存就是使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。 共享内存在进程空间的映射： 使用共享内存通信的一般步骤 1、创建或者打开共享内存 2、
使用共享内存及信号量实现进程间通信例子
03-28
代码实现了共享内存和信号量的结合，实现进程间通信及其同步问题。通过此代码可以理解共享内存及信号量基本函数的使用及实现原理。
Linux进程间通信——使用信号量
haierboos
08-24 4540
这篇文章将讲述别一种进程间通信的机制——信号量。注意请不要把它与之前所说的信号混淆起来，信号与信号量是不同的两种事物。有关信号的更多内容，可以阅读我的另一篇文章：Linux进程间通信——使用信号。下面就进入信号量的讲解。 一、什么是信号量 为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生成并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临...
Linux操作系统学习笔记（十八）进程间通信之共享内存和信号量
ty的博客
09-19 1602
一. 前言   本文为进程间通信的最后一篇，介绍共享内存和信号量。之所以将二者一起叙述，是因为二者有着密不可分的关系。共享内存会利用虚拟内存和物理内存的映射关系，让不同进程开辟一块虚拟空间映射到相同的物理内存上，从而实现了两个进程对相同区域的读写，即进程间通信。而信号量则实现了互斥锁，可以为共享内存提供数据一致性的保证，因此二者常结合使用。 二. 基础知识   共享内存的使用包括 调用shmget()创建共享内存 调用shmat()映射共享内存至进程虚拟空间 调用shmdt()接触映射关系   信号量
C# 进程间通信 共享内存
03-25
特别提醒：共享内存并未提供同步机制，也就是说，在第一个进程结束对共享内存的写操作之前，并无自动机制可以阻止第二个进程开始对它进行读取，所以我们通常需要用其他的机制来同步对共享内存的访问，例如信号量。...
Linux嵌入式操作系统-实验六 进程间通信——共享内存与信号量
CCSco4355
02-19 1594
Linux嵌入式操作系统-实验六 进程间通信——共享内存与信号量
linux使用c++共享内存，信号量同步，进程间通信
最新发布
09-12
由于共享内存和信号量在进程间通信中是非常重要的技术，许多开发者需要深入理解它们的工作原理和使用方法。掌握这些技术有助于设计高效、稳定的多进程应用程序，特别是在需要处理大量数据和高并发场景的应用程序中，...
进程间通信之共享内存与信号量
modi000的博客
12-22 1604
1.概念： 共享内存是System V版本的最后一个进程间通信方式。共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常为同一段物理内存。进程可以将同一段物理内存连接到他们自己的地址空间中，所有的进程都可以访问共享内存中的地址。如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。 特别提醒：共享内存并未提供同步机制，也就是说，在第一个进程结束对共享内存的写操作之前
操作系统：通过共享内存和信号量实现进程间通信（含代码）
俊夫小瞳的博客
06-22 1174
本博代码有一个问题：只有父子进程的某一方在读取，没有父子交替读取。我也不知道为什么，但是应付作业还是可以的。1、原理说明我是这样理解题目的，进程A一行一行地读取某个文件，并把一行的内容存入共享内存中，等待进程B或者进程C将其读走并将共享内存清空后再继续读取下一行的内容，直到文件结束。而进程B和进程C都等待着进程A在共享内存中放入数据后并发互斥地读取缓冲区并将缓冲区清空，也就是说，共享内存缓冲区的内容每次只能由进程B或者进程C中的一个读取。如下图所示。从上图我们可以总结出： 进程A和进程B之间有互斥关系； 进
共享内存和信号量的使用
leeshine优快云的博客
07-02 601
共享内存
共享内存——信号量使用
weixin_45725491的博客
05-26 346
#include<stdio.h> #include<stdlib.h> #include<unistd.h> #include<sys/shm.h> #include<string.h> #include<assert.h> int main() { int shmid = shmget((key_t)1234,256,IPC_creat|0600);//创建共享内存或获取一个已存在的共享内存的id assert( shmid !=
实验六 Linux共享内存,Linux进程同步与通讯：共享内存和信号量的使用
weixin_34723270的博客
05-11 743
Linux进程同步与通讯：共享内存和信号量的使用实验目的加深对进程同步于通信操作的直观认识掌握Linux操作系统的进程、线程机制和编程接口掌握Linux操作系统的进程和线程间的同步和通信机制掌握经典同步问题的编程方法题目要求一个程序(进程)从客户端读入按键信息，一次将一行按键信息保存到一个共享存储的缓冲区内并等待读取进程将数据读走，不断重复上面的操作；另一个程序(进程)生成两个进程/线程，用于显示...
linux 进程间共享内存与信号量的使用
helloEnya001的专栏
08-22 676
最近写程序涉及到进程间内存共享与读写访问锁的问题。 写个测试用的小程序。可以很好的模拟。 主程序。testM。  申请一块共享内存。 通过信号量进行控制。快速读写。 #include #include #include #include #include #include #include #include #include #include typedef struc
进程间通信---信号量的使用
12-13 176
Linux信号量操作_sunxiaopengsun的专栏-优快云博客_linux 信号量
使用信号量和共享内存实现进程间通信
bluestar的专栏
10-11 2919
共享内存是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制。通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。共享内存往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。 使用共享存储来实现进程间通信的注意点是对数据存取的同步，必须确保当一个进程去读取数据时，它所想要的数据已经写好了。通常，信号量被要来实现对共享存储数据存取的同步，另外，可
Linux详解 --- 进程间通信2 (共享内存、信号量)
wuqiongjin的博客
02-06 2022
共享内存：共享内存的查看及删除、共享内存建立的过程、申请共享内存、将共享存、挂接到进程地址空间中、'去'关联共享内存、释放共享内存、如何使用共享内存 信号量
Linux——进程间通信，信号量的使用
ting160126的专栏
03-01 119
信号量只看.从.c和.h文件，文字描述一下把。sem.h文件中声明了四个方法，比如信号量的初始化，资源的释放和占用，信号量的销毁、sem.c文件就是队sem.h头文件的实现。main.c和test.c就是两个进程，我们两个进程都占用屏幕来输出，但是我们再同一时间，只想让一个进程来使用我们的屏幕，这就得用来我们的信号量。下面我们来看一看各个文件的具体实现把。
进程间的通信方式（一）之——共享内存和信号量
weixin_45389997的博客
01-17 1600
本文详细介绍了进程间通信的两种方式：共享内存和信号量，对其应用场景和4（共享内存）+3（信号量）个接口函数进行了详细说明，并进行实战演练，通过运行结果更加直观的了解它们的通信机制。共享内存往往是结合信号量来实现进程间的同步和通信的，因此又给出例程阐述如何引入信号量来实现对共享资源的互斥访问。
进程间通信新实践：共享内存与信号量的结合示例
共享内存和信号量是操作系统中实现进程间通信（IPC）的重要机制。在Linux系统中，这些机制被广泛使用，尤其在C语言的系统编程中。本篇文章将详细介绍如何使用共享内存和信号量在Linux环境下实现进程间的通信及其同步...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值