进程与线程（四）

基于System V IPC对象的进程间通信机制

IPC对象和文件一样,必须先创建,每个IPC对象都有特定Key值,ID值,拥有者,权限和使用大小等，但其读写操作不能使用普通文件的read/write方式。

SystemV IPC引入

1、在传统的UNIX通信机制上进行了优化，形成一种更新的进程间通信机制
2、基于System V IPC相关的通信方式，全部使用ID来访问内存空间（数据存储的空
间）
2-1：ID的来源：创建或者打开内存空间时，内核给用户返回的
思考：毫无关系的两个进程如何得知同一片内存空间的ID？
—》空间谁创建的？
用户进程自己！（哪个用户来创建不限制）
办法：
创建者按照key值来创建并打开内核中的内存空间，最后拿到ID
使用者也按照同一个key值来打开内存空间，最后也能拿到同样的ID
2-2：Key值的来源：
key的来源1：key值是被创建出来的，通信双方只要使用同样的方式，即可获取到同一个Key
key的来源2：直接传入IPC_PRIVATE(死值)–》适合具有亲缘关系的进程间通信

查看Linux系统中IPC工具的方式

查看所有IPC工具

命令：ipcs

在这里插入图片描述

查看指定的IPC工具

查看消息队列：
ipcs -q
删除消息队列：
ipcrm -q msgid(ID值)
查看共享内存：
ipcs -m
删除共享内存：
ipcrm -m shmid
查看信号灯集：
ipcs -s
删除信号灯集：
ipcrm -s semid

在这里插入图片描述

key值获取方法：ftok()函数

在这里插入图片描述

消息队列

消息队列的特征：

1、消息队列是IPC对象的一种，实现两个进程间少量的收据传输,使用率最高
2、消息队列由消息队列ID来唯一标识
3、消息队列就是一个消息的列表（特殊的链式队列）。用户可以在消息队列中添加消息、读取消息等。
4、消息队列可以按照类型来发送/接收消息，先入先出(同一类型),不同类型的消息可以随机存取。
5、数据存放在内核当中

在这里插入图片描述

消息队列的操作

打开或者创建消息队列

在这里插入图片描述

添加消息

在这里插入图片描述

读取消息

在这里插入图片描述

控制消息队列（删除消息队列）

在这里插入图片描述
案例：创建消息队列收发消息
消息队列添加消息代码：

#include 
#include 
#include 
#include 
#include 
#include 
#define N 100
//消息结构
typedef struct msgbuf
{
	long mtype; //消息类型
	char mtext[N]; //消息正文
}MSG;
int main(int argc, const char *argv[])
{
	//1，获取key值
	key_t key = ftok("./", 88);
	if(key < 0)
	{
		perror("ftok error");
		return -1;
	}
	printf("ftok ok! key = %d\n",key);
	//2，打开或者创建消息队列，获得ID值
	int msgid = msgget(key, IPC_CREAT | 0664);
	if(msgid < 0)
	{
		perror("msgget error");
		return -1;
	}
	printf("msgget ok! msgid = %d\n",msgid);
	//3，发送消息
	//构造消息
	//给消息类型赋值
	MSG m1;
	bzero(&m1, sizeof(m1));
	m1.mtype = 100;
	printf("请输入发送的第1个消息:\n");
	fgets(m1.mtext, sizeof(m1.mtext), stdin);
	MSG m2;
	bzero(&m2, sizeof(m2));
	//给消息类型赋值
	m2.mtype = 100;
	printf("请输入发送的第2个消息:\n");
	fgets(m2.mtext, sizeof(m2.mtext), stdin);
	MSG m3;
	bzero(&m3, sizeof(m3));
	//给消息类型赋值
	m3.mtype = 300;
	printf("请输入发送的第3个消息:\n");
	fgets(m3.mtext, sizeof(m3.mtext), stdin);
	//发送消息
	msgsnd(msgid, &m2, strlen(m2.mtext), 0);
	msgsnd(msgid, &m1, strlen(m1.mtext), 0);
	msgsnd(msgid, &m3, strlen(m3.mtext), 0);
	//删除消息队列
	//msgctl(msgid, IPC_RMID, NULL);
	return 0;
}

消息队列读取消息代码：

#include 
#include 
#include 
#include 
#include 
#include 
#define N 100
//消息结构
typedef struct msgbuf
{
	long mtype; //消息类型
	char mtext[N]; //消息正文
}MSG;
int main(int argc, const char *argv[])
{
	//1，获取key值
	key_t key = ftok("./", 88);
	if(key < 0)
	{
		perror("ftok error");
		return -1;
	}
	printf("ftok ok! key = %d\n", key);
	//2，打开或者创建消息队列，获得ID值
	int msgid = msgget(key, IPC_CREAT | 0664);
	if(msgid < 0)
	{
		perror("msgget error");
		return -1;
	}
	printf("msgget ok! msgid = %d\n", msgid);
	//3，读取消息
	MSG readMsg;
	bzero(&readMsg, sizeof(readMsg));
	msgrcv(msgid, &readMsg, sizeof(readMsg.mtext), 0, 0);//参数3为0 默认读取第
	一条消息
	//打印读取的消息
	printf("读取的队列中第一条消息为:%s\n", readMsg.mtext);
	//删除消息队列
	//msgctl(msgid, IPC_RMID, NULL);
	return 0;
}

在这里插入图片描述
注意：消息队列中的消息是读取一条则少一条，添加一条则多一条！

共享内存

共享内存的特征

1、共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存（映射之后的内存空间），而不需要任何数据的拷贝
2、为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间
3、进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。
4、由于多个进程共享一段内存，因此也需要依靠某种同步机制，如互斥锁和信号量等

命令管道和消息队列就存在数据拷贝的过程：如下图
在这里插入图片描述

而共享内存之所以高效的图解：如下：
在这里插入图片描述
注意：内核空间只有一份，所有进程的内核空间都是共享的。

共享内存的操作

打开或者创建共享内存

在这里插入图片描述

映射共享内存到用户的私有空间

在这里插入图片描述

取消映射

在这里插入图片描述

删除共享内存

在这里插入图片描述
案例：共享内存实现数据的交互
共享内存写端代码：

#include 
#include 
#include 
#include 
int main(int argc, const char *argv[])
{
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	printf("请输入写入到共享内存的信息:\n");
	fgets(p, 1024, stdin);
	//取消映射
	if(shmdt(p) < 0)
	{
		perror("shmdt error");
		return -1;
	}
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

共享内存读端代码：

#include 
#include 
#include 
#include 
int main(int argc, const char *argv[])
{
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	//读取共享内存中的消息
	printf("读取的结果为:");
	fputs(p, stdout);
	//取消映射
	if(shmdt(p) < 0)
		return -1;
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

在这里插入图片描述
思考：要是./r此时先运行，则会出现什么情况？

注意：要是想要让该两个进程之间形成一种同步关系，比如：先输入，再输出！如何实现？？？
—》进程间通信时，要同步可以使用有名信号量！！！
优化：使用有名信号量将上述共享内存的代码优化为同步（先输入，再输出）
共享内存的写端代码：

#include 
#include 
#include 
#include 
#include  /* For O_* constants */
#include  /* For mode constants */
#include 
#include 
#include 
sem_t *pFgets,*pFputs;
//信号处理函数
void func(int sig)
{
	//关闭有名信号量
	sem_close(pFgets);
	sem_close(pFputs);
	//删除有名信号量
	sem_unlink("SEM_FEGTS");
	sem_unlink("SEM_FPUTS");
	exit(0);
}
int main(int argc, const char *argv[])
{
	//注册一个信号和处理函数
	signal(SIGINT, func);
	//创建2个有名信号量
	pFgets = sem_open("SEM_FEGTS", O_RDWR | O_CREAT, 0664, 1);
	if(pFgets == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fgets ok!");
	pFputs = sem_open("SEM_FPUTS", O_RDWR | O_CREAT, 0664, 0);
	if(pFputs == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fputs ok!");
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	while(1)
	{
		//申请资源（P操作）
		sem_wait(pFgets);
		printf("请输入写入到共享内存的信息:\n");
		fgets(p, 1024, stdin);
		//释放资源（V操作）
		sem_post(pFputs);
	}
	//取消映射
	if(shmdt(p) < 0)
	{
		perror("shmdt error");
		return -1;
	}
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

共享内存的读端代码：

#include 
#include 
#include 
#include 
#include  /* For O_* constants */
#include  /* For mode constants */
#include 
#include 
#include 
sem_t *pFgets,*pFputs;
void func(int sig)
{
	//关闭有名信号量
	sem_close(pFgets);
	sem_close(pFputs);
	//删除有名信号量
	sem_unlink("SEM_FEGTS");
	sem_unlink("SEM_FPUTS");
	exit(0);
}
int main(int argc, const char *argv[])
{
	//安装信号和处理函数
	signal(SIGINT, func);
	pFgets = sem_open("SEM_FEGTS", O_RDWR | O_CREAT, 0664, 1);
	if(pFgets == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fgets ok!");
	pFputs = sem_open("SEM_FPUTS", O_RDWR | O_CREAT, 0664, 0);
	if(pFputs == SEM_FAILED)
	{
		printf("sem_open error");
		return -1;
	}
	printf("sem_open_fputs ok!");
	//完成key值的获取
	key_t key = ftok("./", 22);
	if(key < 0)
		return -1;
	printf("ftok ok!\n");
	//共享内存区域申请
	int shmid = shmget(key, 1024, IPC_CREAT | 0664);
	if(shmid < 0)
		return -1;
	printf("shmget ok!\n");
	//映射共享内存到用户私有空间
	char *p = (char *)shmat(shmid, NULL, 0);//0代表共享内存此时可读可写
	if(p == (char *)-1)
		return -1;
	printf("shmat ok!\n");
	//操作
	while(1)
	{
		//申请资源（P操作）
		sem_wait(pFputs);
		//读取共享内存中的消息
		printf("读取的结果为:");
		fputs(p, stdout);
		//释放资源（V操作）
		sem_post(pFgets);
	}
	//取消映射
	if(shmdt(p) < 0)
		return -1;
	printf("shmdt ok!\n");
	//删除共享内存
	/*
	if(shmctl(shmid, IPC_RMID, NULL) < 0)
	return -1;
	printf("shmctl ok!\n");
	*/
	return 0;
}

在这里插入图片描述
当用户在键入输入ctrl c 之后，因为安装了信号处理函数，因此将有名信号量进行了删除，演示如下：

信号量

无名信号量

线程之间需要同步！

有名信号量（有名信号量的位置：/dev/shm/）

进程之间需要同步！

创建有名信号量

#include /* For O_* constants /
#include / For mode constants */
#include
sem_t *sem_open(const char *name, int oflag,
mode_t mode, unsigned int value);
参数1：有名信号量的名字（自己起）
参数2：打开方式：O_RDWR O_RDONLY O_WRONLY O_CREAT
参数3：有名信号量的权限：0664
参数4：给有名信号量的初始值（功能类似于无名信号量的初始化数值的函数sem_init（））
Link with -pthread. //编译要连接pthread库！！！
返回值：成功返回指向有名信号量的指针失败返回SEM_FAILED

申请资源（p操作）

#include
int sem_wait(sem_t *sem);

释放资源（V操作）

#include
int sem_post(sem_t *sem);

关闭有名信号量

#include
int sem_close(sem_t *sem);

删除有名信号量

#include
int sem_unlink(const char *name);
参数：有名信号量的名字

案例：使用有名信号量实现进程1先打印hello 进程2再打印world
进程1代码：

#include 
#include 
#include 
#include 
#include 
#include  /* For O_* constants */
#include  /* For mode constants */
#include 
int main(int argc, const char *argv[])
{
	//创建2个有名信号量
	sem_t *pSem1 = sem_open("SEM_1", O_RDWR | O_CREAT, 0664, 1);
	if(SEM_FAILED == pSem1)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_1 ok!\n");
	sem_t *pSem2 = sem_open("SEM_2", O_RDWR | O_CREAT, 0664, 0);
	if(SEM_FAILED == pSem2)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_2 ok!\n");
	while(1)
	{
		//申请资源
		sem_wait(pSem1);
		printf("hello\n");
		sleep(1);
		//释放资源
		sem_post(pSem2);
	}
	//关闭有名信号量
	sem_close(pSem1);
	sem_close(pSem2);
	//删除有名信号量
	sem_unlink("SEM_1");
	sem_unlink("SEM_2");
	return 0;
}

进程2代码：

#include 
#include 
#include 
#include 
#include 
#include  /* For O_* constants */
#include  /* For mode constants */
#include 
int main(int argc, const char *argv[])
{
	//创建2个有名信号量
	sem_t *pSem1 = sem_open("SEM_1", O_RDWR | O_CREAT, 0664, 1);
	if(SEM_FAILED == pSem1)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_1 ok!\n");
	sem_t *pSem2 = sem_open("SEM_2", O_RDWR | O_CREAT, 0664, 0);
	if(SEM_FAILED == pSem2)
	{
		perror("sem_open error");
		return -1;
	}
	printf("sem_open SEM_2 ok!\n");
	while(1)
	{
		//申请资源
		sem_wait(pSem2);
		printf("world\n");
		sleep(1);
		//释放资源
		sem_post(pSem1);
	}
	//关闭有名信号量
	sem_close(pSem1);
	sem_close(pSem2);
	//删除有名信号量
	sem_unlink("SEM_1");
	sem_unlink("SEM_2");
	return 0;
}

在这里插入图片描述
使用有名管道实现循环聊天
思路：
1、创建两个有名管道，搭配两个子线程，双方对于其中某一个进行你发我收，另一个我发你收即可。
2、双方的收发各自使用线程处理函数解决

eg:clien1.c
#include 
//发送消息
void * send_func(void *arg)
{
	//write :fd, buf, strlen()/sizeof()
	mkfifo("com1.txt", 0664);
	int fw = open("com1.txt", O_WRONLY);
	while(1)
	{
		write(fw, buf, strlen(buf));
	}
}
//接收消息
void * recv_func(void *arg)
{
	mkfifo("com2.txt", 0664);
	int fr = open("com2.txt", O_RDONLY);
	while(1)
	{
		read(fr, buf, sizeof(buf));
	}
}
int main()
{
	//创建两个子进程
	//定义保存线程ID的变量
	pthread_t sendTHID;//保存发送子线程的ID号
	pthread_t recvTHID;//保存结束子线程的ID号
	pthread_create(&sendTHID, NULL, &send_func, NULL);
	pthread_create(&recvTHID, NULL, &recv_func, NULL);
	//线程分离 ---》当子线程结束时，自动释放其资源
	pthread_detach(sendTHID);
	pthread_detach(recvTHID);
	return 0;
}

eg:clien2.c
#include 
//发送消息
void * send_func(void *arg)
{
	//write :fd, buf, strlen()/sizeof()
	mkfifo("com2.txt", 0664);
	int fw = open("com2.txt", O_WRONLY);
	while(1)
	{
		write(fw, buf, strlen(buf));
	}
}
//接收消息
void * recv_func(void *arg)
{
	mkfifo("com1.txt", 0664);
	int fr = open("com1.txt", O_RDONLY);
	while(1)
	{
		read(fr, buf, sizeof(buf));
	}
}
int main()
{
	//创建两个子进程
	//定义保存线程ID的变量
	pthread_t sendTHID;//保存发送子线程的ID号
	pthread_t recvTHID;//保存结束子线程的ID号
	pthread_create(&sendTHID, NULL, &send_func, NULL);
	pthread_create(&recvTHID, NULL, &recv_func, NULL);
	//线程分离 ---》当子线程结束时，自动释放其资源
	pthread_detach(sendTHID);
	pthread_detach(recvTHID);
	return 0;
}

安装SIGCHLD信号，回收子进程的退出资源（僵尸进程的资源处理）

#include 
//使用信号处理函数让父进程回收子进程的退出资源
void reclamation_func(int signum)
{
	//回收资源
	/*
	//注意：while()循环只是起到可以进入处理函数内部时，一次性回收好几个子进程的退出资源
	思考：如果不加while()循环，则好几个子进程的退出资源需要好几次进入处理函数内部
	去回收
	while(waitpid(-1, NULL, WNOHANG) < 0)
	{
	;
	}
	*/
	int ret = waitpid(-1, NULL, WNOHANG);
	if(ret < 0)
	{
		perror("waitpid error");
	}
	else if(0 == waitpid)
	{
		printf("还未结束...\n");
	}
	else
	{
		printf("回收子进程OK 其PID = %d\n",ret);
	}
}
int main()
{
	//安装信号：绑定SIGCHLD信号 和一个回收子进程退出资源的信号处理函数
	signal(SIGCHLD, reclamation_func);
	pid_t pid = fork();
	if(pid < 0)
	exit(-1);
	else if (0 == pid)
	{
		//子进程
		printf("I am child Process!\n");
	}
	else
	{
		//父进程
		printf("I am Parent Process!\n");
		while(1);
	}
}

相关阅读:
css实现的动态导航菜单，倾斜放置，鼠标悬停回正html前端源码
 AI全栈大模型工程师(十五)记忆封装：Memory
模板、策略以及工厂模式
 mdadm命令详解及实验过程
 【vue】使用无障碍工具条（详细）
常用的openssl命令
 API性能监控【ApiHelp】-- 组件Enhance 代码实现 ~ ASM字节码增强
 每日实用技巧分享：怎么修复老照片？
qt判断当前日期是不是当月的最后一天
 Granular Ball Computing (GBC)
原文地址：https://blog.csdn.net/xuezhe_____/article/details/139381132

进程与线程（四）

进程与线程（四）

基于System V IPC对象的进程间通信机制

SystemV IPC引入

查看Linux系统中IPC工具的方式

查看所有IPC工具

命令：ipcs

查看指定的IPC工具

key值获取方法：ftok()函数

消息队列

消息队列的特征：

消息队列的操作

打开或者创建消息队列

添加消息

读取消息

控制消息队列（删除消息队列）

共享内存

共享内存的特征

共享内存的操作

打开或者创建共享内存

映射共享内存到用户的私有空间

取消映射

删除共享内存

信号量

无名信号量

有名信号量 （有名信号量的位置：/dev/shm/）

创建有名信号量

申请资源（p操作）

释放资源（V操作）

关闭有名信号量

删除有名信号量

有名信号量（有名信号量的位置：/dev/shm/）