进程间通信（IPC）：共享内存（shared memory）和信号量（semaphore)

最新推荐文章于 2024-04-09 17:15:51 发布
最新推荐文章于 2024-04-09 17:15:51 发布
阅读量4.9k 收藏 61
点赞数 13
分类专栏： Linux系统编程 文章标签： linux ipc 多进程 嵌入式 内核
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49638344/article/details/119652712
版权

共享内存和信号量

共享内存

🌔🌔🌔🌔🌔

  • 共享内存就是使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。
  • 共享内存在进程空间的映射：
    在这里插入图片描述

使用共享内存通信的一般步骤

1、创建或者打开共享内存
2、进程A连接（映射）共享内存，写入数据
3、进程A断开
4、进程B连接（映射）共享内存，读取数据
5、进程B断开
6、释放共享内存

  • 示意图：在这里插入图片描述

创建共享内存

  • shmget函数：

    #include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size,int shmflg);
    • 功能：创建或打开一块共享内存区。
    • 参数：
      • key：进程间通信键值，ftok() 的返回值。
      • size：该共享存储段的长度(字节)。
      • shmflg：标识函数的行为及共享内存的权限，其取值如下：
        • IPC_CREAT：如果不存在就创建
        • IPC_EXCL： 如果已经存在则返回失败
        • 位或权限位：共享内存位或权限位后可以设置共享内存的访问权限
    • 返回值： 成功返回共享内存标识符；失败返回-1。

共享内存的映射和解除映射

  • shmat函数：

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

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

    • 功能： 将一个共享内存段映射到调用进程的数据段中

    • 参数：

      • shmid：共享内存标识符，shmget() 的返回值。
      • shmaddr：共享内存映射地址(若为 NULL 则由系统自动指定)，推荐使用 NULL。
      • shmflg：共享内存段的访问权限和映射条件( 通常为 0 )，具体取值如下：
        • 0：共享内存具有可读可写权限。
        • SHM_RDONLY：只读。
        • SHM_RND：（shmaddr 非空时才有效）

    • 返回值： 成功返回共享内存段映射地址( 相当于这个指针就指向此共享内存 ) ；失败返回-1

  • shmdt函数：

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

int shmdt(const void *shmaddr);

    • 功能： 将共享内存和当前进程分离

    • 参数：

      • shmaddr：共享内存映射地址。

    • 返回值： 成功0 ；失败-1

共享内存操作函数

  • shmct函数：

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

int shmctl(int shmid, int cmd, struct shmid_ds *buf);
    • 功能： 共享内存属性的控制。
    • 参数：

      • shmid：共享内存标识符。

      • cmd：函数功能的控制，其取值如下：

        • IPC_RMID：删除
        • IPC_SET：设置 shmid_ds 参数，相当于把共享内存原来的属性值替换为 buf 里的属性值。
        • IPC_STAT：保存 shmid_ds 参数，把共享内存原来的属性值备份到 buf 里。
        • SHM_LOCK：锁定共享内存段( 超级用户 )。
        • SHM_UNLOCK：解锁共享内存段。
        • SHM_LOCK 用于锁定内存，禁止内存交换。并不代表共享内存被锁定后禁止其它进程访问。

      • buf：shmid_ds 数据类型的地址，用来存放或修改共享内存的属性。

  • 返回值： 成功0 ；失败-1

示例代码

  • 本例程未使用信号量，写端停留5秒等待读端读取信息，配合信号量使用的代码见文末

  • 写进程shm_w.c

    #include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
    int shmid; //共享内存标识符
    char *shmaddr;
    key_t key;
    key = ftok(".",1);     //获取键值
    shmid = shmget(key,1024*4,IPC_CREAT|0666); //打开或者创建共享内存
    if(shmid == -1){
        printf("shmget NO OK\n");
        exit(-1);
    ｝
    shmaddr = shmat(shmid,0,0);  //共享内存连接到当前进程的地址空间
    printf("shmat ok\n");
    strcpy(shmaddr,"hello world"); //向内存中写入数据
    sleep(5);                 //睡眠5秒，等待内存数据被读走
    shmdt(shmaddr);            //断开进程和内存的连接
    shmctl(shmid,IPC_RMID,0);  //删除共享内存段
    printf("quit\n");
    return 0;
}

  • 读进程shm_r.c

    #include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
    int shmid;
    char *shmaddr;
    key_t key;
    key = ftok(".",1);        //获取键值
    shmid = shmget(key,1024*4,0); //打开创建的共享内存，获取内存ID，
    if(shmid == -1){
        printf("shmget no ok\n");
        exit(-1);
    }
    shmaddr = shmat(shmid,0,0); //共享内存连接到当前进程的地址空间
    printf("shmat ok\n");       //表示连接成功
    printf("data : %s",shmaddr); //将内存地址中的数据读出，打印
    shmdt(shmaddr);              //断开内存和当前进程的连接
    printf("quit\n");
    return 0;
}

信号量

🌔🌔🌔🌔🌔

多任务编程中互斥和同步的概念

  • 互斥：是指散步在不同任务之间的若干程序片断，当某个任务运行其中一个程序片段时，其它任务就不能运行它们之中的任一程序片段，只能等到该任务运行完这个程序片段后才可以运行。最基本的场景就是：一个公共资源同一时刻只能被一个进程或线程使用，多个进程或线程不能同时使用公共资源。
  • 同步：是指散步在不同任务之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。最基本的场景就是：两个或两个以上的进程或线程在运行过程中协同步调，按预定的先后次序运行。比如 A 任务的运行依赖于 B 任务产生的数据。

信号量(Semaphore)

  • 信号量广泛用于进程或线程间的同步和互斥，信号量本质上是一个非负的整数计数器，它被用来控制对公共资源（比如上文说的共享内存）的访问。

  • 信号量可以用来保证两个或多个关键代码段不被并发调用。

  • 在实际应用中两个进程间通信可能会使用多个信号量，因此 System V 的信号量以集合的概念来管理。

  • 信号量集合数据结构：struct semid_ds，此数据结构中定义了整个信号量集的基本属性。

    /* Obsolete, used only for backwards compatibility and libc5 compiles */
struct semid_ds
{
	struct ipc_perm	sem_perm;		/* permissions .. see ipc.h */
	__kernel_time_t	sem_otime;		/* last semop time */
	__kernel_time_t	sem_ctime;		/* last change time */
	struct sem	*sem_base;		/* ptr to first semaphore in array */
	struct sem_queue *sem_pending;		/* pending operations to be processed */
	struct sem_queue **sem_pending_last;	/* last pending operation */
	struct sem_undo	*undo;			/* undo requests on this array */
	unsigned short	sem_nsems;		/* no. of semaphores in array */
};

  • 信号量数据结构：struct sem，此数据结构中定义了信号量的基本属性。

    /* One semaphore structure for each semaphore in the system. */
struct sem
{
	int	semval;		/* current value *信号量的值*/
	int	sempid;		/* pid of last operation *最后一个操作信号量的进程号*/
	struct list_head sem_pending; /* pending single-sop operations */
};

信号量的操作

  • 编程时可根据操作信号量值的结果判断是否对公共资源具有访问的权限，当信号量值大于 0 时，则可以访问，否则将阻塞。

  • PV 原语是对信号量的操作，一次 P 操作使信号量减１，一次 V 操作使信号量加１。（P表示通过，V表示释放）

    • 🔒P 操作：将sem减 1，相减后，如果 sem<0 ，则进程/线程进入阻塞等待，否则继续，表明 P 操作可能会阻塞
    • 🔑V 操作：将 sem 加 1，相加后，如果 sem>0 ，唤醒一个等待中的进程/线程，表明 V 操作不会阻塞
    • 只有sem大于0时P才不会对进程阻塞
    • P 操作是用在进入临界区之前，V 操作是用在离开临界区之后，这两个操作一般是成对出现的。
      在这里插入图片描述

  • 信号量用于互斥：
    在这里插入图片描述

  • 信号量用于同步：
    在这里插入图片描述

相关函数

  • 创建信号量数组

    #include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semget(key_t key, int nsems, int semflg);

    • 功能： 创建或打开一个信号量集合，该集合中可以包含多个信号量。

    • 参数：

      • key：进程间通信键值，通过调用 ftok() 函数得到的键值
      • nsems：创建的信号量的个数。如果只是访问而不创建则可以指定该参数为 0，一旦创建了该信号量， 就不能更改其信号量个数，只要不删除该信号量，重新调用该函数创建该键值的信号量，该函数只是返回以前创建的值，不会重新创建。
      • semflg：标识函数的行为及信号量的权限，其取值如下：
        • IPC_CREAT：创建信号量。
        • IPC_EXCL：检测信号量是否存在。
        • 位或权限位：信号量位或权限位后可以设置信号量的访问权限，格式和 open 函数的 mode_ t一样（open() 的使用请点此链接），但可执行权限未使用。

    • 返回值： 成功返回信号量集标识符；失败返回 -1

  • semop函数对信号量组进行操作

    #include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semop(int semid, struct sembuf *sops, size_t nsops);
struct sembuf{
    unsigned short  sem_num;	/*信号量的序号*/
    short       sem_op;		/*信号量的操作值*/
    short       sem_flg;	/*信号量的操作标识*/
};

    • 功能： 操作信号量，主要进行信号量加减操作。

    • 参数：

      • semid：信号量集标识符。
      • sops：操作信号量的结构体（struct sembuf）数组的首地址( 结构体定义在 sys/sem.h )，此结构体中的数据表明了对信号量进行的操作。

        • 结构体成员使用说明如下：

        • sem_num：信号量集中信号量的序号

        • sem_op 取值如下：

          • sem_op > 0：信号量的值在原来的基础上加上此值。
          • sem_op < 0：如果信号量的值小于 semop 的绝对值，则挂起操作进程。
          • sem_op = 0：对信号量的值进行是否为 0 测试。若为 0 则函数立即返回，若不为 0 则阻塞调用进程
          • 如果信号量的值大于等于 semop 的绝对值， 则信号量的值在原来的基础上减去 semop 的绝对值。

        • sem_flag 取值如下：

          • IPC_NOWAIT：在对信号量的操作不能执行的情况下使函数立即返回。
          • SEM_UNDO：当进程退出后，该进程对信号量进行的操作将被撤销。
      • nsops：操作信号量的结构体数组中元素的个数。

    • 返回值： 成功0 ；失败-1

  • semctl函数控制信号量的相关信息

    #include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

int semctl(int semid, int semnum, int cmd, ...);

union semun{
	int			val;	/*信号量的值*/
	struct semid_ds *buf;	/*信号量集合信息*/
	unsigned short  *array;/*信号量值的数组*/
	struct seminfo  *__buf;/*信号量限制信息*/
};

    • 功能： 对信号量集合以及集合中的信号量进行操作。

    • 参数：

      • semid：信号量集标识符
      • semnum：集合中信号量的序号，指定对哪个信号量操作， 只对几个特殊的 cmd 操作有意义
      • cmd：信号量控制类型。semctl() 函数可能有3个参数，也可能有4个参数，参数的个数由 cmd 决定。第4个参数为联合体。
      • cmd 的取值如下：

        • GETVAL：获取信号量的值。此时函数有3个参数。semctl() 函数的返回值即为信号量的值

        • SETVAL：设置信号量的值。此时函数有4个参数。第4个参数为联合体中的val，其值为信号量的值。

        • IPC_STAT：获取信号量集合的信息。此时函数有4个参数。第4个参数为联合体中的__buf

        • IPC_SET：设置信号量集合的信息。此时函数有4个参数。第4个参数为联合体中的__buf

        • IPC_RMID：删除信号量集。此时函数有3个参数,第2个参数semnum不起作用

        • GETALL：获取所有信号量的值。此时函数有4个参数，第2个参数semnum不起作用。第4个参数为联合体中的array，其值为用来存放所有信号量值的数组的首地址。

        • SETALL：设置所有信号量的值 ，参数说明同上

        • IPC_INFO：获取信号量集合的限制信息。此时函数有4个参数，第2个参数semnum不起作用。

        • GETPID：获取信号的进程号，即最后操作信号量的进程。此时函数有3个参数。 semctl() 函数的返回值即为信号的进程号。

        • GETNCNT：获取等待信号的值递增的进程数。此时函数有3个参数。semctl() 函数的返回值即为进程数。

        • GETZCNT：获取等待信号的值递减的进程数。此时函数有3个参数。semctl() 函数的返回值即为进程数。

    • 返回值： 成功0 ；失败-1

函数使用示例

  • 下例将sem设为0，父进程使用P操作会等待子进程V操作释放

    #include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <unistd.h>

union semun {
    int              val;    /* Value for SETVAL */
    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    unsigned short  *array;  /* Array for GETALL, SETALL */
    struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                (Linux-specific) */
};


void pGetKey(int semid)
{
		struct sembuf set;
		set.sem_num = 0;
		set.sem_op = -1;
		set.sem_flg = SEM_UNDO;
		semop(semid, &set,1);
		printf("get key\n");
}

void vPutKey(int semid)
{
        struct sembuf set;
		set.sem_num = 0;
        set.sem_op = 1;
        set.sem_flg = SEM_UNDO;
        semop(semid, &set,1);
        printf("put key\n");
 }

int main()
{
	key_t key = ftok(".",2);
	int semid = semget(key,1,IPC_CREAT|0666);
	union semun seminit;
	seminit.val = 0;
    semctl(semid,0,SETVAL,seminit);

	int pid = fork();
	if(pid > 0){
		pGetKey(semid);	
		printf("this is father\n");
		vPutKey(semid);
		semctl(semid,0,IPC_RMID);
	}else if(pid == 0){
		printf("this is child\n");
		sleep(5);
		vPutKey(semid);
	}else{
		printf("fork error!\n");
	}	


	return 0;
}

信号量配合共享内存使用

  • 示意图：

在这里插入图片描述

  • 参考信号量的同步模型，建立两个信号量，一个为0，另一个为1

  • 写进程shm_w.c：

    #include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

union semun {
    int              val;    /* Value for SETVAL */
    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    unsigned short  *array;  /* Array for GETALL, SETALL */
    struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                (Linux-specific) */
};


void P(int semid,unsigned short num)
{
		struct sembuf set;
		set.sem_num = num; //信号量在数组里的序号
		set.sem_op = -1; //信号量的操作值
		set.sem_flg = SEM_UNDO; //信号量的操作标识
		semop(semid, &set,1);
		printf("get key\n");
}

void V(int semid,unsigned short num)
{
        struct sembuf set;
		set.sem_num = num;
        set.sem_op = 1;
        set.sem_flg = SEM_UNDO;
        semop(semid, &set,1);
        printf("put key\n");
 }
 
int main()
{
	key_t key1,key2;
    key1 = ftok(".",1);     //获取键值
    key2 = ftok(".",2);
    
    int shmid = shmget(key1,1024*4,IPC_CREAT|0666); //打开或者创建共享内存
    int semid = semget(key2,2,IPC_CREAT|0666);//打开或者创建信号量组
   	
   	union semun seminit; //信号量初始化
	seminit.val = 1; //第一个信号量设置为1
    semctl(semid,0,SETVAL,seminit);
    seminit.val = 0;//第二个信号量设置为0
    semctl(semid,1,SETVAL,seminit);
    
    P(semid,0); //给第一个信号量上锁
    char *shmaddr = shmat(shmid,0,0);  //共享内存连接到当前进程的地址空间
    printf("shmat ok\n");
    strcpy(shmaddr,"hello world"); //向内存中写入数据
    shmdt(shmaddr);            //断开进程和内存的连接
    V(semid,1); //释放第二个信号量
    
    P(semid,0); //等待第一个信号量的释放
    shmctl(shmid,IPC_RMID,0);  //删除共享内存段
    semctl(semid,0,IPC_RMID);   //删除信号量组
  	printf("quit\n");
    return 0;
}

  • 读进程shm_r.c：

    #include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

union semun {
    int              val;    /* Value for SETVAL */
    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    unsigned short  *array;  /* Array for GETALL, SETALL */
    struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                (Linux-specific) */
};


void P(int semid,unsigned short num)
{
		struct sembuf set;
		set.sem_num = num; //信号量在数组里的序号
		set.sem_op = -1; //信号量的操作值
		set.sem_flg = SEM_UNDO; //信号量的操作标识
		semop(semid, &set,1);
		printf("get key\n");
}

void V(int semid,unsigned short num)
{
        struct sembuf set;
		set.sem_num = num;
        set.sem_op = 1;
        set.sem_flg = SEM_UNDO;
        semop(semid, &set,1);
        printf("put key\n");
 }
 
int main()
{
    key_t key1,key2;
    key1 = ftok(".",1);     //获取键值
    key2 = ftok(".",2);
    
    int shmid = shmget(key1,1024*4,IPC_CREAT|0666); //打开或者创建共享内存
    int semid = semget(key2,1,IPC_CREAT|0666);//打开或者创建信号量组
   	    
    P(semid,1); //等待第二个信号量释放
    char *shmaddr = shmat(shmid,0,0); //共享内存连接到当前进程的地址空间
    printf("shmat ok\n");       //表示连接成功
    printf("data : %s\n",shmaddr); //将内存地址中的数据读出，打印
    shmdt(shmaddr);              //断开内存和当前进程的连接
    V(semid,0); //释放第一个信号量
    
    printf("quit\n");
    return 0;
}

  • 因为信号量的初始化在写端，所以先执行写端

  • 终端显示：

    • 写端：
      在这里插入图片描述

    • 读端：
      在这里插入图片描述

money的大雨
关注
  • 13
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
使用共享内存及信号量实现进程间通信例子
03-28
代码实现了共享内存和信号量的结合，实现进程间通信及其同步问题。通过此代码可以理解共享内存及信号量基本函数的使用及实现原理。
linux ipc 带有信号量同步互斥方式的进程间通信
04-14
本案例重点探讨了使用信号量实现的同步互斥的进程间通信，结合了共享内存这一高效的数据交换手段。这里我们将深入解析相关知识点。 首先，让我们了解什么是**信号量（Semaphore）**。信号量是一种同步原语，用于...
进程间通信（IPC）之 信号量（semaphore）
d0203的博客
03-21 131
Linux下的信号量函数都是在通用信号量数组上进行操作，而不是在一个单一的二值信号量上进行操作。保证同一时刻只能有一个进程对某个资源进行访问，下面是一个让子进程先执行去访问资源的例子。最简单的信号量是只能取0和1的变量，这也是信号量最常见的一种形式，也叫二值信号量。每次对信号量的PV操作不仅限于对信号量值加1减1，而且可以加减任意正整数。信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。信号量基于操作系统的PV操作，程序对信号量的操作都是原子操作。而可以取多个正整数的信号量被称为通用信号量。
linux c多进程通信之共享内存和信号量
最新发布
LiaoJunXiong的博客
04-09 289
编译环境：Ubuntu16.04 64位交叉编译工具：arm-hisiv500-linux-gcc。
【Linux】system V进程间通信——共享内存、消息队列、信号量
weixin_60478154的博客
02-22 920
【Linux】system V进程间通信——共享内存、消息队列、信号量
共享内存和信号量
qq_37954088的博客
03-20 4211
共享内存和信号量实现进程间通信的另外两种机制。 一.  共享内存 1. 共享内存的结构 2. 实现共享内存的函数 （1）shmget 函数 功能：创建共享内存 参数：key 共享内存的名字 ，size 共享内存的大小（以页为单位分配资源） 返回值：成功返回一个非负整数，即共享内存的标识符；失败返回-1。 （2）shmat 函数 功能：将共享内存块连接到进程地址空间 ...
进程间的通信方式（一）之——共享内存和信号量
weixin_45389997的博客
01-17 1184
本文详细介绍了进程间通信的两种方式：共享内存和信号量，对其应用场景和4（共享内存）+3（信号量）个接口函数进行了详细说明，并进行实战演练，通过运行结果更加直观的了解它们的通信机制。共享内存往往是结合信号量来实现进程间的同步和通信的，因此又给出例程阐述如何引入信号量来实现对共享资源的互斥访问。
进程间通信之共享内存C#源代码
10-24
3.共享内存（Shared Memory） 4.信号量（Semaphore） 5.消息队列（Message Queues） 6.远程过程调用（Remote Procedure Calls, RPC） 7.Mailslot 8.报文传输协议（Message Transfer Protocol, MTP） 9.串行端口...
ipc.rar_IPC_linux 进程_进程间通信_进程间通信ipc
09-23
如果需要复杂的数据结构和可靠的同步机制，那么共享内存和信号量可能是更好的选择。 在实际开发中，进程间通信是多线程编程、服务间通信、系统设计等领域的关键环节。熟练掌握并灵活运用各种IPC机制，能帮助开发者...
IPC.rar_IPC_进程间的通信
09-23
进程间的通信（IPC，Inter-Process Communication...在跨进程数据共享场景下，共享内存和内存映射文件则更为高效。通过`IPC.rar`中的示例，学习者可以深入理解每种通信方式的工作原理及其应用场景，从而提升编程技能。
VB进程通信-内存共享
03-15
- **通信**：进程通信（IPC, Inter-Process Communication）是指不同进程间交换信息的方式，包括共享内存、管道、消息队列、信号量、套接字等。 2. **内存共享机制**： - 共享内存是一种高效的IPC方法，因为它...
共享内存和信号量的使用
leeshineCSDN的博客
07-02 517
共享内存
进程间通信 六种IPC方式详解
one goto one 的博客
04-21 4994
进程间通信（IPC）介绍 IPC 单机形式有管道、消息队列、信号量、共享储存。多机形式有socket、streams。 一、管道 管道分为无名管道和有名管道。而管道通常指无名管道。 无名管道 特点 工作方式为半双工 ， 一方写另一方只能读（同一时间数据只能单方向流动） 使用只限于具有亲缘关系的进程之间，即父子、兄弟进程之间 管道可以理解为一种特殊的文件，可以使用read、write等函数进行读写， 但它不是普通文件，存在于内存中 数据被读取后就消失，不可进行二次读取 ......
C6678学习-IPC
西澳峰的博客
05-03 1518
IPC: Inter-Processor Communication 处理器间通信，指提供多处理器环境中的处理器之间的通信、相同处理器不同线程间的通信。包括数据传递、数据流和链表。在同一处理器上的其他线程在其他处理器上运行的SYS/BIOS线程GPP处理器上运行的SysLink的线程（例如Linux）QMSS（队列管理器）：发送任务和内核之间的数据SRIO IPC：发送任务、内核和芯片之间的数据。
进程的IPC操作 之 共享内存
qq_40115163的博客
05-15 853
一 共享内存的作用 共享内存主要是用来实现进程间通讯的一种机制，只不过，需要进程间互斥的访问这段内存，因此需要使用信号量等锁机制来对共享内存进行访问。 二 共享内存的实现 共享内存的实现主要由两种方式：一种是shm系统调用；一种是mmap实现共享（因为mmap也可以实现私有映射）的页面映射。 2.1 shm系统调用 shm系统调用主要是在sys/shm.h头文件中。 2.1.1 共享内存的创建 int shmget(key_t key, size_t size, int shmflg);
信号量和信号的区别
a13602955218的博客
04-02 3731
1.信号：（signal）是一种处理异步事件的方式。信号是比较复杂的通信方式，用于通知接受进程有某种事件发生，除了用于进程外，还可以发送信号给进程本身。 2.信号量：（Semaphore）进程间通信处理同步互斥的机制。是在多线程环境下使用的一种设施, 它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。 简单地说，信号就是一种异步通信，通知进程某种事件的发生；信号量是进程/线程同步与互斥...
零基础Linux_18(进程间通信)共享内存+消息队列+信号量
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
10-17 318
零基础Linux_18（进程间通信）system V共享内存进程间通信代码（shmget+shmctl+shmat+shmdt）+消息队列+信号量+笔试选择题。下一篇：进程信号_产生信号+Core_Dump+保存信号。
Linux进程间通讯 | 信号量、共享内存、消息队列
大柳_的博客。
05-27 188
文章目录前言一、临界资源与临界区二、信号量三、信号量使用方法1.常用接口2.使用示例2.输出结果四、共享内存1.什么是共享内存2.代码示例五、消息队列总结 前言 进程间通信的一种方式：信号量 提示：以下是本篇文章正文内容，下面案例可供参考 一、临界资源与临界区 同一时间段只允许一个进程或线程访问的资源叫做临界资源。 访问临界资源的代码段叫临界区。 二、信号量 信号量是一个特殊的变量，一般取正数值。它的值代表允许访问的资源数目，获取资源时，需要对信号量的值进行原子减一，该操作被称为 P 操作当信号量值为
【基础知识】进程通信之共享内存+信号量
walkingMa的专栏
03-03 398
2. 示例代码 新建semaphore.h文件 #ifndef __SEM_H__ #define __SEM_H__ #include&amp;amp;lt;stdio.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; #include&amp;amp;lt;sys/ipc.h&amp;amp;gt; #include&amp;amp;lt;sys/sem.h&am
php进程间通信 ipc结构
07-28
PHP进程间通信（IPC）可以使用多种结构实现，其中一些常见的结构包括： 1. 管道（pipe）：管道是最简单的IPC机制之一，它允许一个进程将输出发送到另一个进程的输入。在PHP中，可以使用`proc_open`函数创建一个管道。 2. 共享内存（shared memory）：共享内存允许多个进程访问同一块内存区域，从而实现数据共享。PHP提供了`shmop`扩展来处理共享内存。 3. 信号量（semaphore）：信号量用于在多个进程之间同步和互斥访问共享资源。PHP中的`sem_acquire`和`sem_release`函数可以用于控制信号量。 4. 消息队列（message queue）：消息队列允许进程通过发送和接收消息来进行通信。在PHP中，可以使用`msg_send`和`msg_receive`函数来实现消息队列。 5. 套接字（socket）：套接字是一种网络通信机制，它可以在不同的主机上的进程之间进行通信。PHP提供了一系列函数来创建和管理套接字。 这些IPC结构各有优缺点，选择合适的结构取决于具体的需求和场景。需要根据应用程序的要求来决定使用哪种IPC结构。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

money的大雨

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

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

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

打赏作者

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

抵扣说明：

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

余额充值