系统编程第四节——共享内存与信号量

最新推荐文章于 2024-08-17 21:38:19 发布
最新推荐文章于 2024-08-17 21:38:19 发布
阅读量1.4k 收藏 18
点赞数 2
分类专栏： 嵌入式之系统编程 文章标签： 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lianggoch/article/details/119135965
版权

系统编程 – 共享内存

一、共享内存的简介

共享内存与消息队列一样，都是IPC对象，所以在使用时必须要先获取key值。
共享内存是进程间通信数据传输效率最高的一种通信方式。

二、共享内存原理

在Linux系统下，程序被加载到内存成为进程时，系统会给这个进程分配它执行所需要的内存空间，但是对于软件应用层的进程来说，是不允许直接操作物理内存的，只能操作”虚拟内存”，虚拟内存与物理内存之间存在MMU(内存管理单元)，实现虚拟内存与物理内存之间的映射关系。
在这里插入图片描述

三、共享内存的缺陷

共享内存的机制是直接从物理内存中申请一片空间作为两个进程共用的一片内存空间，进程在使用共享内存进行通信时，这片空间**完全脱离了Linux内核的管理**，此时进程间不好掌控这片空间的同步关系，共享内存在通信时，一般需要使用信号量来规范进程的同步。

四、相关API

1、 Shmget() //获取共享内存操作ID

SYNOPSIS

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

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

==》key:共享内存的key值
==》size：共享内存的大小（页大小的整数倍 PAGE_SIZE : 4096）
==》shmflg：标志 （如果不存在则创建 IPC_CREAT | 0777）
==》返回值：成功返回共享内存ID,失败返回 -1

2、shmat() //将共享内存映射到进程空间

SYNOPSIS

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

void *shmat(int shmid,const void *shmaddr,int shmflg); //映射空间
void shmdt(const void *shmaddr); //解除映射

==》shmid：共享内存操作ID
==》shmaddr：映射空间的首地址 NULL(系统自动寻找一片合适的空间)
==》shmflg：映射标志 0
==》返回值：成功返回映射空间的地址 ，失败返回 （void *)-1

例子1：

进程A和进程B使用共享内存进行通信，进程A往共享内存写入自己的PID，进程B读取共享内存数据，给目标进程发送信号，然后自己退出。

进程A

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

#define SHM_PATH "." //地址
#define PROJ_ID  5   //用户定义的ID号

#define SHM_SIZE  4096*2  //共享内存的大小

/*进程A*/
int main(int argc, char *argv[])
{
	//1, 获取key值
	key_t key = ftok(SHM_PATH, PROJ_ID);
	if(-1 == key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2, 获取共享内存的ID
	int shmid = shmget(key, SHM_SIZE, IPC_CREAT | 0777);
	if(-1 == shmid)
	{
		perror("shmget failed");
		return -1;
	}
	
	//3, 映射共享内存到进程空间
	char *shmaddr = shmat(shmid, NULL, 0);
	if(shmaddr == (void *)-1)
	{
		perror("shmat failed");
		return -1;
	}
	
	//4, 写入自己的PID到共享内存中
	printf("pid : %d\n", getpid());
	*(pid_t *)shmaddr = getpid();		//把自己的PID赋值到共享内存开头
	
	//5, 等待信号（退出信号）
	pause();
	
	//6, 解除映射
	shmdt(shmaddr);
	
	return 0;
}

进程B

#include <stdio.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <signal.h>

  
#define SHM_PATH "." //地址
#define PROJ_ID  5

#define SHM_SIZE  4096*2 

/*进程B*/
int main(int argc, char *argv[])
{
	//1, 获取key值
	key_t key = ftok(SHM_PATH, PROJ_ID);
	if(-1 == key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2, 获取共享内存的ID
	int shmid = shmget(key, SHM_SIZE, IPC_CREAT | 0777);
	if(-1 == shmid)
	{
		perror("shmget failed");
		return -1;
	}
	
	//3, 映射共享内存到进程空间
	char *shmaddr = shmat(shmid, NULL, 0);
	if(shmaddr == (void *)-1)
	{
		perror("shmat failed");
		return -1;
	}
	
	//4, 获取共享内存中的数据
	printf("pid : %d\n", *(pid_t *)shmaddr);
	
	//5, 发送信号
	kill(*(pid_t *)shmaddr, SIGINT);
	
	//6, 解除映射
	shmdt(shmaddr);
	
	return 0;
}

进程间通信 – 信号量

一、信号量简介

信号量是一个IPC对象，使用时需要获取key值。信号量在进程间通信时，是专门用来规范进程对共享内存使用的，一般会结合共享内存使用。相当于使用共享内存时的”信号灯”。

信号量的本质是 P V操作
P操作 ： 信号量的值减一 (当信号量的值为0，此时P操作会阻塞)
V操作 ： 信号量的值加一

二、信号量与共享内存使用

在这里插入图片描述

三、相关API

1、semget() //获取信号量的操作ID

SYNOPSIS

   #include <sys/types.h>
   #include <sys/ipc.h>
   #include <sys/sem.h>
   
   int semget(key_t key,int nsems,int semflg);

==》key： IPC对象的数组
==》nsems： 信号量的个数 --》信号量数组
==》semflg： IPC_CREAT | 0777 --》信号量不存在则创建
==》返回值： 成功返回信号量操作ID,失败返回-1

2、semop() //信号量 P/V 操作

SYNOPSIS

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

int semop(int semmid,struct sembuf *sops,size_t nsops);

==》semid：信号量的操作ID
==》sops：信号量操作结构体指针
==》nsops：操作信号量数组中元素个数 -->1

struct sembuf{
unsigned short sem_num; /* semaphore number /
short sem_op; / semaphore operation /
short sem_flg; / operation flags */
};

==》sem_num:信号量值的下标（从0开始）
==》sem_op : 信号量操作数 p: -1; v:1
==》sem_flg : 操作标志位 0

3、semctl() //信号量初始值设置

SYNOPSIS

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

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

==》 semid : 信号量操作ID
==》 semnum : 信号量下标
==》 cmd : 命令 SETVAL : 设置信号量的值
==》第四个参数: 如果第三个选择 SETVAL，那么第四个就是设置的信号量的值

例子2：

使用信号量与共享内存实现一个简单的通信功能。
A --> 发送一句话 B --> 读取， 发送一句话 A–> 读取，发送一句话

进程A

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

#define SHM_PATH "."  //地址
#define SEM_PATH "."  //地址

#define ProJ_ID_SHM  10  //用户自定义ID
#define ProJ_ID_SEM  20  //用户自定义ID

#define SHM_SIZE  4096  //共享内存大小


/*共享内存与信号量 -- A*/
int main(int argc, char *argv[])
{
	//1,获取共享内存和信号量的key值
	key_t shm_key, sem_key;
	shm_key = ftok(SHM_PATH, ProJ_ID_SHM);
	sem_key = ftok(SEM_PATH, ProJ_ID_SEM);
	if(-1 == shm_key || -1 == sem_key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2,获取共享内存和信号量的操作ID
	int shmid, semid;
	shmid = shmget(shm_key, SHM_SIZE, IPC_CREAT | 0777);
	semid = semget(sem_key, 2, IPC_CREAT | 0777);
	if(-1 == shmid || -1 == semid)
	{
		perror("get id failed");
		return -1;
	}	
	
	//3,映射共享内存到进程空间
	char * shmaddr = shmat(shmid, NULL, 0);
	if(shmaddr == (void *)-1)
	{
		perror("shmat failed");
		return -1;
	}
	
	//4,设置信号量初始值 --> 0号信号量设置为1, 1号信号量设置为0
	semctl(semid, 0, SETVAL, 1);	//0号信号量设置为1
	semctl(semid, 1, SETVAL, 0);	//1号信号量设置为0
	
	//5,进行通信
	struct sembuf p_sops_0, v_sops_1;
	p_sops_0.sem_num = 0;
	p_sops_0.sem_op = -1;
	p_sops_0.sem_flg = 0;	//对0号信号量进行P操作结构体
	
	v_sops_1.sem_num = 1;
	v_sops_1.sem_op = 1;
	v_sops_1.sem_flg = 0;	//对1号信号量进行V操作结构体
	
	while(1)
	{
		//1) 对信号量0进行p操作  (第2轮循环时在此阻塞)
		semop(semid, &p_sops_0, 1);
		
		//2) 输出共享内存内容 --> printf
		//printf("[%d]readbuf:%s\n",getpid(), shmaddr);
		
		//3) 清空共享内存
		//memset(shmaddr, 0, SHM_SIZE);
		
		//4) 从键盘获取数据写入共享内存
		fgets(shmaddr, SHM_SIZE, stdin);
		//scanf("%s", shmaddr);
		
		//5) 对信号量1进行v操作 (把进程B的阻塞解除)
		semop(semid, &v_sops_1, 1);
		if(strcmp("EXIT\n", shmaddr) == 0)
			break;
	}
	
	//6,解除共享内存映射,  删除信号量,删除共享内存
	shmdt(shmaddr);
	shmctl(shmid, IPC_RMID, NULL);		//删除共享内存
	semctl(semid, 0, IPC_RMID);			//删除信号量
	
	return 0;
}

进程B

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

#define SHM_PATH "."
#define SEM_PATH "."

#define ProJ_ID_SHM  10
#define ProJ_ID_SEM  20

#define SHM_SIZE  4096

/*共享内存与信号量 -- B*/
int main(int argc, char *argv[])
{
	//1,获取共享内存和信号量的key值
	key_t shm_key, sem_key;
	shm_key = ftok(SHM_PATH, ProJ_ID_SHM);
	sem_key = ftok(SEM_PATH, ProJ_ID_SEM);
	if(-1 == shm_key || -1 == sem_key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2,获取共享内存和信号量的操作ID
	int shmid, semid;
	shmid = shmget(shm_key, SHM_SIZE, IPC_CREAT | 0777);
	semid = semget(sem_key, 2, IPC_CREAT | 0777);
	if(-1 == shmid || -1 == semid)
	{
		perror("get id failed");
		return -1;
	}	
	
	//3,映射共享内存到进程空间
	char * shmaddr = shmat(shmid, NULL, 0);
	if(shmaddr == (void *)-1)
	{
		perror("shmat failed");
		return -1;
	}
	
	//4,设置信号量初始值 --> 0号信号量设置为1, 1号信号量设置为0
	semctl(semid, 0, SETVAL, 1);	//0号信号量设置为1
	semctl(semid, 1, SETVAL, 0);	//1号信号量设置为0
	
	//5,进行通信
	struct sembuf p_sops_1, v_sops_0;
	p_sops_1.sem_num = 1;
	p_sops_1.sem_op = -1;
	p_sops_1.sem_flg = 0;	//对1号信号量进行P操作结构体
	
	v_sops_0.sem_num = 0;
	v_sops_0.sem_op = 1;
	v_sops_0.sem_flg = 0;	//对0号信号量进行V操作结构体	
	
	while(1)
	{
		//1) 对信号量1进行p操作  (第1轮循环时在此阻塞)
		semop(semid, &p_sops_1, 1);
		
		//2) 输出共享内存内容 --> printf
		printf("[%d]readbuf:%s",getpid(), shmaddr);
		if(strcmp("EXIT\n", shmaddr) == 0)
			break;
		//3) 清空共享内存
		memset(shmaddr, 0, SHM_SIZE);
		
		//4) 从键盘获取数据写入共享内存
		//fgets(shmaddr, SHM_SIZE, stdin);
		//scanf("%s", shmaddr);
		
		//5) 对信号量0进行v操作 (把进程A的阻塞解除)
		semop(semid, &v_sops_0, 1);
	}
	shmdt(shmaddr);
	
	return 0;
}

例子3：

通过共享内存传输文件

进程A:文件接收端

#include <stdio.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/sem.h>		// /usr/include/sys/sem.h
#include <sys/ipc.h>		// #include "stdio.h"
#include <signal.h>
#include <unistd.h>
#include <string.h>

#define SHM_PATH "/home/gec"
#define SEM_PATH "/home/gec"

#define SHM_ID	10
#define SEM_ID	20

#define SHM_SIZE 4096

/*文件接收端*/
int main(int argc, char *argv[])
{
	//1,获取共享内存,信号量key值 ==> 文件名
	key_t shm_key, sem_key;
	shm_key = ftok(SHM_PATH, SHM_ID);
	sem_key = ftok(SEM_PATH, SEM_ID);
	if(-1 == shm_key || -1 == sem_key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2,获取共享内存,信号量操作ID ==> 文件描述符
	int shmid, semid;
	shmid = shmget(shm_key, SHM_SIZE, IPC_CREAT|0777);
	semid = semget(sem_key, 2, IPC_CREAT|0777);
	if(-1 == shmid || -1 == semid)
	{
		perror("get id  failed");
		return -1;	
	}
	
	//3,共享内存映射到进程空间
	char *shmaddr = (char *)shmat(shmid, NULL, 0);
	if(shmaddr == (void *)-1)
	{
		perror("shmat failed");
		return -1;
	}

	//4, 获取文件大小信息和文件名信息
	long int filesize, recvsize = 0;
	char filename[64] = {0};
	struct sembuf p_sops_1, v_sops_0;
	v_sops_0.sem_num = 0;
	v_sops_0.sem_op = 1;
	v_sops_0.sem_flg = 0;	//0号信号量V操作
		
	p_sops_1.sem_num = 1;
	p_sops_1.sem_op = -1;
	p_sops_1.sem_flg = 0;	//1号信号量p操作
	
	// P(D);	//数据资源量 -1
	semop(semid, &p_sops_1, 1);
	
	sscanf(shmaddr, "%ld:%s", &filesize, filename);
	printf("recv filesize:%ld, filename:%s\n", filesize, filename);
	
	// V(S);	//空间资源量 +1
	semop(semid, &v_sops_0, 1);	
	
	//5, 创建一个同名文件
	FILE *fp = fopen(filename, "w");
	if(NULL == fp)
	{
		perror("fopen failed");
		return -1;
	}	
	
	//6, 读取文件数据填入文件
	while(1)
	{
		//P (D);
		semop(semid, &p_sops_1, 1);
		
		//读取文件数据
		if(filesize - recvsize < SHM_SIZE)
		{
			fwrite(shmaddr, 1, filesize - recvsize, fp);
			printf("recv file finish!\n");
			break;
		}
		else{
			size_t ret = fwrite(shmaddr, 1, SHM_SIZE, fp);
			recvsize += ret;	//已经接收的文件字节数
			if(recvsize >= filesize)	//已经接收完了
			{
				break;
			}	
		}
		//V (S);
		semop(semid, &v_sops_0, 1);	
	}
	fclose(fp);
	
	//8,解除映射,删除共享内存，删除信号量
	shmdt(shmaddr);
	shmctl(shmid, IPC_RMID, NULL);		//删除共享内存
	semctl(semid, 0, IPC_RMID);			//删除信号量
	
	return 0;
}

进程B:文件发送端

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <sys/sem.h>		// /usr/include/sys/sem.h
#include <sys/ipc.h>		// #include "stdio.h"
#include <signal.h>
#include <unistd.h>
#include <string.h>

#define SHM_PATH "/home/gec"
#define SEM_PATH "/home/gec"

#define SHM_ID	10
#define SEM_ID	20

#define SHM_SIZE 4096

/*文件发送端*/
int main(int argc, char *argv[])
{
	//0,规定程序执行格式  ./test2_A filename
	if(argc != 2)
	{
		printf("请按照格式执行:%s <filename>\n", argv[0]);
		return -1;
	}
	
	//1,获取共享内存,信号量key值 ==> 文件名
	key_t shm_key, sem_key;
	shm_key = ftok(SHM_PATH, SHM_ID);
	sem_key = ftok(SEM_PATH, SEM_ID);
	if(-1 == shm_key || -1 == sem_key)
	{
		perror("ftok failed");
		return -1;
	}
	
	//2,获取共享内存,信号量操作ID ==> 文件描述符
	int shmid, semid;
	shmid = shmget(shm_key, SHM_SIZE, IPC_CREAT|0777);
	semid = semget(sem_key, 2, IPC_CREAT|0777);
	if(-1 == shmid || -1 == semid)
	{
		perror("get id  failed");
		return -1;	
	}
	
	//3,共享内存映射到进程空间
	char *shmaddr = (char *)shmat(shmid, NULL, 0);
	if(shmaddr == (void *)-1)
	{
		perror("shmat failed");
		return -1;
	}

	//4,信号量初始化  空间资源信号量0 S=1,  数据资源信号量1 D=0
	semctl(semid, 0, SETVAL, 1);		//S 信号量
	semctl(semid, 1, SETVAL, 0);		//D 信号量
	
	struct sembuf p_sops_0, v_sops_1;
	p_sops_0.sem_num = 0;
	p_sops_0.sem_op = -1;
	p_sops_0.sem_flg = 0;	//0号信号量p操作
		
	v_sops_1.sem_num = 1;
	v_sops_1.sem_op = 1;
	v_sops_1.sem_flg = 0;	//1号信号量v操作
	
	//5,获取文件信息 --> stat : 获取文件大小
	struct stat buf;
	stat(argv[1], &buf);
	FILE *fp = fopen(argv[1], "r");
	if(NULL == fp)
	{
		perror("fopen failed");
		return -1;
	}
	
	printf("filename:%s, filesize:%ld\n", argv[1], buf.st_size);

	//6, 发送文件大小信息和文件名信息
	semop(semid, &p_sops_0, 1); //P (S);
	
	memset(shmaddr, 0, SHM_SIZE);
	sprintf(shmaddr, "%ld:%s", buf.st_size, argv[1]);//发送文件信息
	
	//V (D);
	semop(semid, &v_sops_1, 1);
	
	//7, 循环发送文件内容
	while(1)
	{
		semop(semid, &p_sops_0, 1); //P (S);
		
		memset(shmaddr, 0, SHM_SIZE);
		size_t ret = fread(shmaddr, SHM_SIZE, 1, fp);
		if(0 == ret)
		{
			printf("send file finish\n");
			semop(semid, &v_sops_1, 1);
			if(feof(fp))
				break;
		}
		//V (D);
		semop(semid, &v_sops_1, 1);
	}
	
	fclose(fp);
	//8,解除映射
	shmdt(shmaddr);
	
	return 0;
}
qmy_lhl
关注
专栏目录
【并发编程六】c++进程通信——信号量（semaphore)
junxuezheng的博客
11-17 7853
信号量是操作系统提供的一种协调共享资源访问的方法。信号量则由操作系统进行管理，地位高于进程，操作系统保证信号量的原子性。
Linux——Linux系统编程之进程间的通信-信号量Semaphore的使用总结（基本概念、创建信号量、操作信号量、初始化信号量、使用实践测试）
数字世界 万物互联
01-20 658
目录 0 引言 1 信号量的基本概念 2 信号量常用相关函数 2.1 创建信号量semget 2.2 改变信号量的值semop 2.3 初始化信号量semctl 3 信号量的使用实践 0 引言 前面几篇博客中介绍了进程间通信方式（有名管道、无名管道、消息队列、信号）都存在一个问题，存在多个进程同时访问一个资源的可能，在一些米面临关键数据临界访问的应用时，需要进行排他性的通信，这时候可以使用信号量。 1 信号量的基本概念 信号量其实就是一种特殊的变量，访问具有原子性，用于多进程对共享数据
进程间的通信方式（一）之——共享内存和信号量
weixin_45389997的博客
01-17 1375
本文详细介绍了进程间通信的两种方式：共享内存和信号量，对其应用场景和4（共享内存）+3（信号量）个接口函数进行了详细说明，并进行实战演练，通过运行结果更加直观的了解它们的通信机制。共享内存往往是结合信号量来实现进程间的同步和通信的，因此又给出例程阐述如何引入信号量来实现对共享资源的互斥访问。
底软驱动 | 进程间通信之共享内存和信号量
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
07-13 879
共享内存和信号量是有着相似性有可以共同使用从而完成进程通信的手段。下面引用极客时间中的两幅图来总结二者的整个过程。
共享内存、消息队列、信号量
最新发布
qq_51216031的博客
08-17 842
一般来说，共享内存、消息队列、信号量详解这三个技术，用的不多，简单认识了即可。如果想进一步了解，可以接着AI学习。
进程间通信（IPC）：共享内存（shared memory）和信号量（semaphore)
Rain土的博客
08-12 5969
共享内存和信号量共享内存使用共享内存通信的一般步骤创建共享内存共享内存的映射和解除映射共享内存操作函数示例代码信号量多任务编程中互斥和同步的概念信号量(Semaphore)信号量的操作相关函数函数使用示例信号量配合共享内存使用 共享内存 ???????????????????? 共享内存就是使得多个进程可以访问同一块内存空间，是最快的可用IPC形式。往往与其它通信机制，如信号量结合使用，来达到进程间的同步及互斥。 共享内存在进程空间的映射： 使用共享内存通信的一般步骤 1、创建或者打开共享内存 2、
Linux操作系统学习笔记（十八）进程间通信之共享内存和信号量
ty的博客
09-19 1508
一. 前言   本文为进程间通信的最后一篇，介绍共享内存和信号量。之所以将二者一起叙述，是因为二者有着密不可分的关系。共享内存会利用虚拟内存和物理内存的映射关系，让不同进程开辟一块虚拟空间映射到相同的物理内存上，从而实现了两个进程对相同区域的读写，即进程间通信。而信号量则实现了互斥锁，可以为共享内存提供数据一致性的保证，因此二者常结合使用。 二. 基础知识   共享内存的使用包括 调用shmget()创建共享内存 调用shmat()映射共享内存至进程虚拟空间 调用shmdt()接触映射关系   信号量
共享内存和信号量
qq_37954088的博客
03-20 4274
共享内存和信号量实现进程间通信的另外两种机制。 一.  共享内存 1. 共享内存的结构 2. 实现共享内存的函数 （1）shmget 函数 功能：创建共享内存 参数：key 共享内存的名字 ，size 共享内存的大小（以页为单位分配资源） 返回值：成功返回一个非负整数，即共享内存的标识符；失败返回-1。 （2）shmat 函数 功能：将共享内存块连接到进程地址空间 ...
信号量 共享内存
wuhanshuo的博客
07-05 249
信号量 p 获取资源 -1 （有可能阻塞） v 释放资源 +1 属于原子操作（不可被分割） 临界资源 ：同一时刻只允许一个进程访问的资源 临界区：访问临界资源的代码段 大概过程： 1. 创建信号量，并初始化 2. 对信号量进行pv操作 3. 销毁信号量 例： ...
【共享内存和信号量】
m0_46112340的博客
05-23 976
(2)V(sv):我们将释放信号量称为V操作，释放信号量的本质就是归还临界资源中某块资源的使用权限，当释放成功时临界资源中资源的数目就应该加一，因此V操作本质就是让计数器加一，如果有其他进程因等待sv而被挂起，就让它恢复运行，如果没有进程因等待sv而挂起，就给他加1。(1)P(sv):我们将申请信号量称为P操作，申请信号量的本质就是申请获得临界资源中某块资源的使用权限，当申请成功时临界资源中资源的数目应该减去一，因此P操作的本质就是让计数器减一，如果sv的值大于零，就给它减1；通常用于获取资源的使用权；
操作系统实验报告——进程管道消息信号量共享存储区通信实验
m0_56267074的博客
12-22 840
操作系统实验Linux
进程间通信(十四)——信号量编程应用：对共享内存的同步访问
Scroll_C的博客
03-16 1366
信号量编程应用：对共享内存的同步访问 system V 信号量编程应用 对共享内存的同步访问 通过读写信号量实现对共享内存的同步互斥访问 实现一个二元信号量协议 读信号量：当为1时，读进程才能进行P操作、读取数据，否则会阻塞 写信号量：当为1时，写进程才能进行p操作、写入数据，否则会阻塞 int semctl(int semid, int semnum, int cmd, ...); semctl函数对一个信号量执行各种控制操作。 semctl() 在semid标识的信..
进程间通信之共享内存与信号量
modi000的博客
12-22 1482
1.概念： 共享内存是System V版本的最后一个进程间通信方式。共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常为同一段物理内存。进程可以将同一段物理内存连接到他们自己的地址空间中，所有的进程都可以访问共享内存中的地址。如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。 特别提醒：共享内存并未提供同步机制，也就是说，在第一个进程结束对共享内存的写操作之前
共享内存和信号量的使用
leeshineCSDN的博客
07-02 551
共享内存
进程间通信--信号量+共享内存
楚小狂
05-16 1254
信号量是一个计数器，常用于处理进程和线程的同步问题，特别是对临界资源访问的同步。获取一次信号量的操作就是对信号量减一，而释放一次信号量的操作就是对信号量加一。Linux内核为每个信号集提供了一个semid_ds数据结构.该结构定义如下(linux/sem.h):/* Obsolete, used only for backwards compatibility and libc5 compiles */struct  semid_ds {     struct  ipc_perm    sem_per
进程通信之共享内存，信号量
sakura0908的博客
03-11 947
进程通信之共享内存，信号量测试代码
共享内存和信号量(Systm V)
qq_22207951的博客
04-27 537
信号量有两种实现：传统的System V信号量和新的POSIX信号量。它们所提供的函数很容易被区分：对于所有System V信号量函数，在它们的名字里面没有下划线。例如，应该是semget()而不是sem_get()。然而，所有的的POSIX信号量函数都有一个下划线。下面列出了它们提供的所有函数清单： Systm V POSIX semctl() sem_getval...
java并发编程(二十九)——浅谈信号量
程序员资料站
01-03 4278
信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release Semaphore VI分别放置在每个关键代码段的首末端。确认这些信号量VI引用的是初始创建的信号量。
共享内存，信号量
qq_45633736的博客
09-30 167
一、进程之间的通信。--- 共享内存。 1、什么是共享内存？机制如何？ 共享内存也是属于IPC对象，所以在使用之前，必须为共享内存申请key值。 共享内存由于存在于运行内存上，运行内存在linux下所有的进程都可以访问到，结论就是任意的两个进程都可以通过共享内存进行通信。 实现步骤： key值 -> ID号 -> 共享内存地址 -> 数据交换 -> 撤销映射。 2、 共享内存函数接口？ 1）先申请key值。 key = ftok(".",10); 2）根据申请到的k...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值