进程线程的通信-day5

已于 2024-02-22 21:49:10 修改
阅读量433 收藏 9
点赞数 7
文章标签： 算法
于 2024-02-22 21:01:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yexiadeyu/article/details/136241679
版权

1、将互斥机制的代码实现重新敲一遍。

#include<myhead.h>

//临界资源
int num=520;

//1、创建一个互斥锁变量
pthread_mutex_t mutex;



void *task1(void *arg);
void *task2(void *arg);
int main(int argc, const char *argv[])
{
	//2、初始化互斥锁
	pthread_mutex_init(&mutex,NULL);

	//定义线程
	pthread_t tid1,tid2;
	if(pthread_create(&tid1,NULL,task1,NULL)!=0)
	{
		printf("tid1 create error\n");
		return 0;
	}
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		printf("tid2 create error\n");
		return 0;
	}
	//获取tid号
	printf("tid1:%#lx,tid2:%#lx\n",tid1,tid2);
	//回收线程资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);

	//5、摧毁锁资源
	pthread_mutex_destroy(&mutex);
	return 0;
}
//任务1函数
void *task1(void *arg)
{
	//3、获取锁资源
	pthread_mutex_lock(&mutex);
	num = 1314;
	sleep(3);
	printf("task1:num=%d\n",num);
	//4、释放锁资源
	pthread_mutex_unlock(&mutex);
}
//任务2函数
void *task2(void *arg)
{
	//3、获取锁资源
	pthread_mutex_lock(&mutex);
	num ++;
	sleep(1);
	printf("task2:num=%d\n",num);
	//4、释放锁资源
	pthread_mutex_unlock(&mutex);
}


2、将无名信号量的代码实现重新敲一遍。

#include<myhead.h>

//1、创建无名信号量
sem_t sem;

void *task1(void *arg);
void *task2(void *arg);
int main(int argc, const char *argv[])
{
	//2、初始化无名信号量
	sem_init(&sem,0,0);

	//定义线程
	pthread_t tid1,tid2;
	if(pthread_create(&tid1,NULL,task1,NULL)!=0)
	{
		printf("tid1 create error\n");
		return 0;
	}
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		printf("tid2 create error\n");
		return 0;
	}
	//获取tid号
	printf("tid1:%#lx,tid2:%#lx\n",tid1,tid2);
	//回收线程资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);

	//5、释放无名信号量
	sem_destroy(&sem);
	return 0;
}
//任务1函数
void *task1(void *arg)
{
	int num=5;
	while(num--)
	{
		sleep(1);
		puts("我生产一辆特斯拉");
		//4、释放资源
		sem_post(&sem);
	}
	pthread_exit(NULL);
}
//任务2函数
void *task2(void *arg)
{
	int num=5;
	while(num--)
	{
		//3、申请资源
		sem_wait(&sem);
		puts("我买了一辆特斯拉");
	}
	pthread_exit(NULL);
}


3、将条件变量的代码实现重新敲一遍。

#include<myhead.h>

//1、定义条件变量
pthread_cond_t cond;

//11、定义互斥锁变量
pthread_mutex_t mutex;

void *task1(void *arg);
void *task2(void *arg);
int main(int argc, const char *argv[])
{
	//2、初始化条件变量
	pthread_cond_init(&cond,NULL);
	//22、初始化互斥锁
	pthread_mutex_init(&mutex,NULL);

	//定义线程
	pthread_t tid1,tid2,tid3,tid4,tid5,tid6;
	if(pthread_create(&tid1,NULL,task1,NULL)!=0)
	{
		printf("tid1 create error\n");
		return 0;
	}
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		printf("tid2 create error\n");
		return 0;
	}
	if(pthread_create(&tid3,NULL,task2,NULL)!=0)
	{
		printf("tid3 create error\n");
		return 0;
	}
	if(pthread_create(&tid4,NULL,task2,NULL)!=0)
	{
		printf("tid4 create error\n");
		return 0;
	}
	if(pthread_create(&tid5,NULL,task2,NULL)!=0)
	{
		printf("tid5 create error\n");
		return 0;
	}
	if(pthread_create(&tid6,NULL,task2,NULL)!=0)
	{
		printf("tid6 create error\n");
		return 0;
	}
	
	printf("tid1:%#lx,tid2:%#lx,tid3:%#lx,tid4:%#lx,tid5:%#lx,tid6:%#lx\n",\
			tid1,tid2,tid3,tid4,tid5,tid6);

	//回收线程资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	pthread_join(tid3,NULL);
	pthread_join(tid4,NULL);
	pthread_join(tid5,NULL);
	pthread_join(tid6,NULL);

	//5、摧毁条件变量
	pthread_cond_destroy(&cond);
	//55、摧毁互斥锁
	pthread_mutex_destroy(&mutex);
	return 0;
}
//定义生产者函数
void *task1(void *arg)
{
	int num=5;
	while(num--)
	{
		sleep(1);
		printf("%#lx:生产了一辆特斯拉\n",pthread_self());
		
		//3、唤醒一个消费者
		pthread_cond_signal(&cond);

	}
	pthread_exit(NULL);
}
//定义消费者函数
void *task2(void *arg)
{
	//33、上锁
	pthread_mutex_lock(&mutex);
	//4、进入等待队列
	pthread_cond_wait(&cond,&mutex);
	
	printf("%#lx:购买了一辆特斯拉\n",pthread_self());
	//4、解锁
	pthread_mutex_unlock(&mutex);
	pthread_exit(NULL);
}


4、将无名管道的代码实现重新敲一遍。

#include<myhead.h>
//管道进程传输
int main(int argc, const char *argv[])
{
	//创建管道文件
	int pipefd[2]={0};
	if(pipe(pipefd)==-1)
	{
		perror("pipe error");
		return -1;
	}
	printf("pipefd[0]=%d,pipefd[1]=%d\n",pipefd[0]),pipefd[1];
	
	//创建子进程
	pid_t pid=fork();
	if(pid>0)
	{
		//父进程
		//关闭管道读端
		close(pipefd[0]);

		char wbuf[128]="";

		while(1)
		{
			//清空wbuf数组
			bzero(wbuf,sizeof(wbuf));

			//终端输入数据
			fgets(wbuf,sizeof(wbuf),stdin);
			wbuf[strlen(wbuf)-1]='\0';

			//将数据写入管道文件中
			write(pipefd[1],wbuf,strlen(wbuf));

			//输入结束条件
			if(strcmp(wbuf,"quit")==0)
				break;

		}
		//关闭管道写端
		close(pipefd[1]);

		//阻塞回收子进程资源
		wait(NULL);
	}else if(pid == 0)
	{
		//子进程
		//关闭管道写端
		close(pipefd[1]);

		char rbuf[128]="";
		while(1)
		{
			//清空rbuf内容
			bzero(rbuf,sizeof(rbuf));

			//从管道文件中读取数据
			read(pipefd[0],rbuf,sizeof(rbuf));

			//输出rbuf的数据
			printf("父进程传来的数据为：%s\n",rbuf);

			//读取结束条件
			if(strcmp(rbuf,"quit")==0)
				break;
		}
		//关闭管道读端
		close(pipefd[0]);

		exit(EXIT_SUCCESS);
	}else
	{
		perror("fork error");
		return -1;
	}
	
	return 0;
}


5、将有名管道的代码实现重新敲一遍。

#include<myhead.h>
int main(int argc, const char *argv[])
{
	//创建一个管道文件
	if(mkfifo("./myfifo",0664)==-1)
	{
		perror("mkfifo error");
		return -1;
	}

	//阻塞
	getchar();

	//清楚文件
	system("rm myfifo");
	return 0;
}

#include<myhead.h>
int main(int argc, const char *argv[])
{
	//打开管道文件
	int wfd=-1;
	//以只写的形式打开文件
	if((wfd=open("./myfifo",O_WRONLY))==-1)
	{
		perror("open error");
		return -1;
	}

	//定义容器
	char wbuf[128]="";
	while(1)
	{
		printf("please enter>>>");
		fgets(wbuf,sizeof(wbuf),stdin);
		//把'\n'变为'\0'
		wbuf[strlen(wbuf)-1]='\0';

		//数据写入管道
		write(wfd,wbuf,strlen(wbuf));

		//终端输入结束条件
		if(strcmp(wbuf,"quit")==0)
			break;
	}
	//关闭文件
	close(wfd);
	return 0;
}

#include<myhead.h>
int main(int argc, const char *argv[])
{
	//打开管道文件
	int rfd=-1;
	//以只读形式打开文件
	if((rfd = open("./myfifo",O_RDONLY))==-1)
	{
		perror("open error");
		return -1;
	}

	//定义容器
	char rbuf[128]="";
	while(1)
	{
		//清空rbuf数组
		bzero(rbuf,sizeof(rbuf));

		//读取管道文件的数据
		read(rfd,rbuf,sizeof(rbuf));

		//输出结果
		printf("收到的数据为：%s\n",rbuf);

		//读取结束条件
		if(strcmp(rbuf,"quit")==0)
			break;
	}
	//关闭文件
	close(rfd);
	return 0;
}


6、使用有名管道完成两个进程的相互通信(提示:可以使用多进程或多线程完成)。

//管道创建函数
#include<myhead.h>
int main(int argc, const char *argv[])
{
	//创建二个管道文件
	if(mkfifo("./text1",0664)==-1)
	{
		perror("text1 error");
		return -1;
	}
	if(mkfifo("./text2",0664)==-1)
	{
		perror("text2 error");
		return -1;
	}
	
	//阻塞
	getchar();

	//清楚文件
	system("rm text1");
	system("rm text2");
	return 0;
}

//用户1发送和接受函数
#include<myhead.h>
int main(int argc, const char *argv[])
{
	pid_t pid=fork();
	if(pid>0)
	{
		//打开管道文件
		int wfd=-1;
		//以只写的形式打开文件
		if((wfd=open("./text1",O_WRONLY))==-1)
		{
			perror("open error");
			return -1;
		}

		//定义容器
		char wbuf[128]="";
		while(1)
		{
			printf("please enter>>>");
			fgets(wbuf,sizeof(wbuf),stdin);
			//把'\n'变为'\0'
			wbuf[strlen(wbuf)-1]='\0';

			//数据写入管道
			write(wfd,wbuf,strlen(wbuf));

			//终端输入结束条件
			if(strcmp(wbuf,"quit")==0)
				break;
		}
		//关闭文件
		close(wfd);		//打开管道文件

	}
	else if(pid==0)
	{
		//打开管道文件
		int rfd=-1;
		//以只读形式打开文件
		if((rfd = open("./text2",O_RDONLY))==-1)
		{
			perror("open error");
			return -1;
		}

		//定义容器
		char rbuf[128]="";
		while(1)
		{
			//清空rbuf数组
			bzero(rbuf,sizeof(rbuf));

			//读取管道文件的数据
			read(rfd,rbuf,sizeof(rbuf));

			//输出结果
			printf("收到的数据为：%s\n",rbuf);

			//读取结束条件
			if(strcmp(rbuf,"quit")==0)
				break;
		}
		//关闭文件
		close(rfd);
	}
	else 
	{
		perror("fork error");
		return -1;
	}
	return 0;
}

//用户2发送接受函数
#include<myhead.h>
int main(int argc, const char *argv[])
{
	pid_t pid=fork();
	if(pid>0)
	{
		//打开管道文件
		int rfd=-1;
		//以只读形式打开文件
		if((rfd = open("./text1",O_RDONLY))==-1)
		{
			perror("open error");
			return -1;
		}

		//定义容器
		char rbuf[128]="";
		while(1)
		{
			//清空rbuf数组
			bzero(rbuf,sizeof(rbuf));
	
			//读取管道文件的数据
			read(rfd,rbuf,sizeof(rbuf));

			//输出结果
			printf("收到的数据为：%s\n",rbuf);

			//读取管道文件的数据取结束条件
			if(strcmp(rbuf,"quit")==0)
				break;
		}
		//关闭文件
		close(rfd);
	}
	else if(pid==0)
	{	
		//打开管道文件
		int wfd=-1;
		//以只写的形式打开文件
		if((wfd=open("./text2",O_WRONLY))==-1)
		{
			perror("open error");
			return -1;
		}

		//定义容器
		char wbuf[128]="";
		while(1)
		{
			printf("please enter>>>");
			fgets(wbuf,sizeof(wbuf),stdin);
			//把'\n'变为'\0'
			wbuf[strlen(wbuf)-1]='\0';

			//数据写入管道
			write(wfd,wbuf,strlen(wbuf));

			//终端输入结束条件
			if(strcmp(wbuf,"quit")==0)
			break;
		}
		//关闭文件
		close(wfd);
	}
	else 
	{
		perror("fork error");
		return -1;
	}
	return 0;
}

7、思维导图

yexiadeyu
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python 08、多任务编程多线程 3-1_进程间通信、同步互斥、threading线程_Day03_AM.mp4
03-09
python 08、多任务编程多线程 3-1_进程间通信、同步互斥、threading线程_Day03_AM.mp4
嵌入式学习-IO进程与线程-Day6
weixin_51597107的博客
01-08 376
【代码】嵌入式学习-IO进程与线程-Day6。
L5进程、线程和进程间通信--有名管道和无名管道（day6）
楚子航
05-31 439
一、进程间通信介绍 概念：就是进程和进程之间交换信息。 常用通信方式 无名管道（pipe） 有名管道 （fifo） 信号（signal） 共享内存(mmap) 套接字（socket） 过时的IPC通信方式 System V IPC 共享内存（share memory） 消息队列（message queue） 信号灯集（semaphore set） 二、无名管道 无名管道具有如下特点： 只能用于具有亲缘关系的进程之间的通信 单工的通信模式，具有固定的读端和写端 无名管道创建时会返回两个文件描述
进程线程通信day2
weixin_52238362的博客
08-23 76
L5进程、线程和进程间通信--线程的取消和互斥（day4）
楚子航
05-26 623
一、线程的取消 意义：随时杀掉一个线程 int pthread_cancel(pthread_t thread); 运行段错误调试： 可以使用gdb调试 使用gdb 运行代码，gdb ./youapp (gdb) run 等待出现Thread 1 "pcancel" received signal SIGSEGV, Segmentation fault. 输入命令bt（打印调用栈） (gdb) bt #0 0x00007ffff783ecd0 in vfprintf () fr...
L5进程、线程和进程间通信--线程的创建和回收（day3）
楚子航
05-25 409
一、线程的概念 1、进程 进程有独立的地址空间 Linux为每个进程创建task_struct 每个进程都参与内核调度，互不影响 2、线程 进程在切换时系统开销大 很多操作系统引入了轻量级进程LWP 同一进程中的线程共享相同地址空间 Linux不区分进程、线程 3、线程特点 通常线程指的是共享相同地址 空间的多个任务 使用多线程的好处 大大提高了任务切换的效率 避免了额外的TLB & cache的刷新 4、线程共享资源和线程私有资源 一个进程中的多个线程共享以下资源..
python多线程DAY04.txt
04-27
前情回顾 1. 信号处理 signal() * 异步通信方式 ---》 同步执行 异步执行 2. 信号量 Semaphore() ...6. 线程通信 使用全局变量通信 线程的同步互斥 7. Python线程 GIL 影响 ： 同一时刻只能解释一个线程，造成
python多线程DAY01.txt
04-27
2.本地套接字 AF_UNIX 本地两个进程间的消息通信 3.多任务编程 * 并行 和 并发 * 进程 线程 4. 多进程编程 时间片 PCB PID 父子进程 优先级 进程特征 进程状态： 就绪态 运行态 等待态 5. ps -aux ps -ajx ...
python多线程DAY03.txt
04-27
4.进程间通信 管道 消息队列 共享内存 信号 信号量 套接字 管道： Pipe() fd.recv() fd.send() 消息队列： Queue() q.get() q.put() q.full() q.empty() q.qsize() q.close() 共享内存： Value() Array() ...
python网络编程DAY01.txt
04-27
2.进程线程 （5天） 3.MongoDB 数据库 （4天） 4.正则表达式 （1.5天） 5.项目（2.5天） 6. git的使用（1天） 网络编程 网络功能 : 数据传输 ISO(国际标准化组织) OSI七层模型 ---》 网络通信工作流程的标准化 ...
链接表存储图(C++注释详解): 构建表 & 深度优先遍历 (DFS)
H13420972436的博客
05-15 421
代码实现: 构建表 & 深度优先遍历 (DFS)
BERT系列算法解读
qq_52053775的博客
05-19 32
从而提高模型在SQuAD、MNLI和SST-2数据集上的性能。总的来看，这些优化措施显著增强了模型的表现。
【力扣一轮】454.四数之和 && 383.赎金信
最新发布
诚。
05-22 185
为什么能想到这里，注意到它的和是0，（和可以是任何数）这样就相当于两两数组为一对，看其中一对数组中的元素，在另外一对数组中是否出现了相反数。这里的一对说的是A+B或其他组合方式，（不重要，因为都是随机的）然而以上想法截止到第二句，都没问题，需要注意的是，不是全对应。A2：因为在存储时，不仅要存储对应的元素，也要存储元素出现的次数，所以用到map。结合之前的有效字母异位符，数组，set，map，使用数组即可。也就是说如果一对数组中有两个-2，另一对数组中只有一个2，那么计算为0的次数为2。
每天五分钟计算机视觉：多目标检测模型的Anchor Box算法详解
huanfeng_AI的博客
05-16 139
我们前面学习了目标检测算法，然而算法是有问题的，也就是分割图片的小格子中只能检测到一个对象，如果要是一个小格中有多个对象的中心点，那么这个就没有办法解决了为了解决这个问题，我们可以使用目标检测中的Anchor Box算法，它可以完成这种任务。目标检测中的Anchor Box算法在近年来得到了广泛的应用，尤其在深度学习领域的目标检测任务中，它发挥了至关重要的作用。
【算法】前缀和——二维前缀和模板题
2302_79031646的博客
05-21 185
用“二维前缀和模板题”来介绍二位前缀和算法模板
基于地理坐标的高阶几何编辑工具算法（8）——整形面
HouGISer的博客
05-19 597
整形面算法常用于快速修改一个几何面的局部形状。
算法练习第22天|39. 组合总和、40.组合总和II
Brillian123的博客
05-15 819
39. 组合总和39. 组合总和 - 力扣（LeetCode）
代码随想录算法训练营第五十五天|LeetCode583.两个字符串的删除操作 、LeetCode72.编辑距离
m0_64514622的博客
05-16 873
dp[i][j]:表示以下标i-1为结尾的word1,和以j-1为结尾的字符串word2，想要达到相等，所需要删除元素的最少次数。dp[i][j]:表示以下标i-1为结尾的word1,和以j-1为结尾的字符串word2，最近编辑距离为dp[i][j]word2为空字符串，以i-1为结尾的字符串word1要要删除i个元素才能和word2相同。word1为空字符串，以j-1为结尾的字符串word2要要删除j个元素才能和word1相同。操作三：word1替换word1[i-1]，使其与word2[j-1]相同。
力扣-219. 存在重复元素 II
ls3614140的博客
05-19 96
给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k。如果存在，返回 true；否则，返回 false。输入：nums = [1,2,3,1,2,3], k = 2。输入：nums = [1,2,3,1], k = 3。输入：nums = [1,0,1,1], k = 1。
day--和--day区别
04-18
例如，如果有一个变量day的值为5，执行day--操作后，day的值将变为4，并且表达式的结果为5。这个操作符通常用于循环或迭代中，用于递减计数器或索引。 2. "day"是一个变量名或标识符，用于表示一个存储数据的位置。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值