IO进程线程day6

思维导图：

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

#include<myhead.h>
int num=520;//临界资源

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

//定义任务１函数
void *task1(void *arg)
{
	printf("我是任务１：\n");

	//3.获取锁资源
	pthread_mutex_lock(&mutex);

	num=1314;
	sleep(3);
	printf("task1:num=%d\n",num);

	//4.释放锁资源
	pthread_mutex_unlock(&mutex);
}

//定义任务２函数
void *task2(void *arg)
{
	printf("我是任务２：\n");

	//获取锁资源
	pthread_mutex_lock(&mutex);

	num++;
	sleep(1);
	printf("task2:num=%d\n",num);

	//释放锁资源
	pthread_mutex_unlock(&mutex);

}
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;
	}

	printf("tid1:%#lx,tid2:%#lx\n",tid1,tid2);

	//回收线程资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);

	//5.销毁锁资源
	pthread_mutex_destroy(&mutex);

	return 0;
}

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

#include<myhead.h>
//1.创建无名信号量
sem_t sem;

//定义生产者线程
void *task1(void *arg)
{
	int num=5;
	while(num--)
	{
		sleep(1);
		printf("我生产了一个煤气罐\n");

		//4.释放资源
		sem_post(&sem);
	}
	//退出线程
	pthread_exit(NULL);
}
//定义消费者线程
void *task2(void *arg)
{
	int num=5;
	while(num--)
	{
		//申请资源
		sem_wait(&sem);


		printf("我消费了一个煤气罐\n");

	}
	//退出线程
	pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
	//２．初始化无名信号量
	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;
	}
	printf("tid1:%#lx,tid2:%#lx\n",tid1,tid2);

	//回收线程资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);

	//释放无名信号量
	sem_destroy(&sem);

	return 0;
}

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

#include<myhead.h>
//1.定义条件变量
pthread_cond_t cond;

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

//定义生产者线程
void *task1(void *arg)
{
	int num=5;
	while(num--)
	{
		sleep(1);
		printf("%#lx:生产了一辆特斯拉\n",pthread_self());

		//唤醒一个消费者
		//pthread_cond_signal(&cond);
	}
	//唤醒所有的等待线程
	pthread_cond_broadcast(&cond);

	//退出线程
	//pthread_exit(NULL);
}
//定义消费者线程
void *task2(void *arg)
{
	//33.上锁
	pthread_mutex_lock(&mutex);

	//进入等待队列
	pthread_cond_wait(&cond,&mutex);

	printf("%#lx:消费了一辆特斯拉\n",pthread_self());

	//解锁
	pthread_mutex_unlock(&mutex);

	//退出线程
	pthread_exit(NULL);
}//定义消费者线程
void *task3(void *arg)
{
	//33.上锁
	pthread_mutex_lock(&mutex);

	//进入等待队列
	pthread_cond_wait(&cond,&mutex);

	printf("%#lx:消费了一辆特斯拉\n",pthread_self());

	//解锁
	pthread_mutex_unlock(&mutex);

	//退出线程
	pthread_exit(NULL);
}
//定义消费者线程
void *task4(void *arg)
{
	//33.上锁
	pthread_mutex_lock(&mutex);

	//进入等待队列
	pthread_cond_wait(&cond,&mutex);

	printf("%#lx:消费了一辆特斯拉\n",pthread_self());

	//解锁
	pthread_mutex_unlock(&mutex);

	//退出线程
	pthread_exit(NULL);
}
//定义消费者线程
void *task5(void *arg)
{
	//33.上锁
	pthread_mutex_lock(&mutex);

	//进入等待队列
	pthread_cond_wait(&cond,&mutex);

	printf("%#lx:消费了一辆特斯拉\n",pthread_self());

	//解锁
	pthread_mutex_unlock(&mutex);

	//退出线程
	pthread_exit(NULL);
}
//定义消费者线程
void *task6(void *arg)
{
	//33.上锁
	pthread_mutex_lock(&mutex);

	//进入等待队列
	pthread_cond_wait(&cond,&mutex);

	printf("%#lx:消费了一辆特斯拉\n",pthread_self());

	//解锁
	pthread_mutex_unlock(&mutex);

	//退出线程
	pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
	//2.初始化条件变量
	pthread_cond_init(&cond,NULL);

	//初始化互斥锁
	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,task3,NULL)!=0)
	{
		printf("tid3 create error\n");
		return 0;
	}
	if(pthread_create(&tid4,NULL,task4,NULL)!=0)
	{
		printf("tid4 create error\n");
		return 0;
	}
	if(pthread_create(&tid5,NULL,task5,NULL)!=0)
	{
		printf("tid5 create error\n");
		return 0;
	}
	if(pthread_create(&tid6,NULL,task6,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;
}

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)
		{
			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.将有名管道的代码实现重新敲一遍。

create.c

#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;
}

rec.c

#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)
	{
		//清空数组
		bzero(rbuf,sizeof(rbuf));

		//读取管道中数据
		read(rfd,rbuf,sizeof(rbuf));

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

		//判断结果
		if(strcmp(rbuf,"quit")==0)
		{
			break;
		}
	}
	//关闭文件
	close(rfd);
	return 0;
}

snd.c

#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("请输入>>>");
		fgets(wbuf,sizeof(wbuf),stdin);
		wbuf[strlen(wbuf)-1]=0;

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

		//判断结果
		if(strcmp(wbuf,"quit")==0)
		{
			break;
		}
	}

	//关闭文件
	close(wfd);
	return 0;
}

6.使用有名管道完成两个进程的相互通信（提示：可以使用多进程或多线程完成）

create.c

#include<myhead.h>
int main(int argc, const char *argv[])
{
	//创建有名管道文件1
	if(mkfifo("./myfifo1",0664) !=0 )
	{
		perror("myfifo1 error");
		return -1;
	}
	
	//创建有名管道文件2
	if(mkfifo("./myfifo2",0664) !=0 )
	{
		perror("myfifo2 error");
		return -1;
	}
 
	printf("文件创建成功\n");
	//使用getchar阻塞
	getchar();
 
	system("rm myfifo1 myfifo2");
	
	return 0;
}

rec.c

#include<myhead.h>
int main(int argc, const char *argv[])
{
	pid_t pid;
	pid=fork();
	if(pid>0)
	{
		//以只写的形式打开管道文件1
		int wfd = -1;
		if((wfd = open("./myfifo1", O_WRONLY)) == -1)
		{
			perror("open error");
			return -1;
		}
 
		//向管道文件1中循环写入数据
		char wbuf[128]="";
		while(1)
		{
			//清空内容
			bzero(wbuf, sizeof(wbuf));
 
			//从终端输入数据
			printf("请输入：\n");
 
			//刷新缓存区
			fflush(stdout);
 
			//从终端读取数据
			read(0, wbuf, sizeof(wbuf));
			wbuf[strlen(wbuf)-1] = '\0';
 
			write(wfd, wbuf, sizeof(wbuf));
 
			if(strcmp(wbuf,"quit") == 0)
				break;
		}
	}
	else if(pid==0)
	{
		//以只读的形式打开管道文件2
		int rfd = -1;
		if((rfd = open("./myfifo2", O_RDONLY)) == -1)
		{
			perror("open error");
			return -1;
		}
 
		//向管道文件2中循环写入数据
		char rbuf[128]="";
		while(1)
		{
			//清空内容
			bzero(rbuf, sizeof(rbuf));
 
			//从管道2中读取数据
			read(rfd, rbuf, sizeof(rbuf));
 
			printf("收到消息：%s\n",rbuf);
 
			//判断结束
			if(strcmp(rbuf,"quit") == 0)
				break;
		}
		exit(EXIT_SUCCESS);
	}
 
	wait(NULL);
 
	return 0;
}

snd.c

#include<myhead.h>
int main(int argc, const char *argv[])
{
	pid_t pid;
	pid=fork();
	if(pid>0)
	{
		//以只读的形式打开管道文件1
		int rfd = -1;
		if((rfd = open("./myfifo1", O_RDONLY)) == -1)
		{
			perror("open error");
			return -1;
		}
 
		//向管道文件1中循环写入数据
		char rbuf[128]="";
		while(1)
		{
			//清空内容
			bzero(rbuf, sizeof(rbuf));
 
			//从管道1中读取数据
			read(rfd, rbuf, sizeof(rbuf));
 
			printf("收到消息：%s\n",rbuf);
 
			//判断结束
			if(strcmp(rbuf,"quit") == 0)
				break;
		}
	}
	else if(pid==0)
	{
		//以只写的形式打开管道文件2
		int wfd = -1;
		if((wfd = open("./myfifo2", O_WRONLY)) == -1)
		{
			perror("open error");
			return -1;
		}
 
		//向管道文件2中循环写入数据
		char wbuf[128]="";
		while(1)
		{
			//清空内容
			bzero(wbuf, sizeof(wbuf));
 
			//从终端输入数据
			printf("请输入：\n");
 
			//刷新缓存区
			fflush(stdout);
 
			//从终端读取数据
			read(0, wbuf, sizeof(wbuf));
			wbuf[strlen(wbuf)-1] = '\0';
 
			write(wfd, wbuf, sizeof(wbuf));
 
			if(strcmp(wbuf,"quit") == 0)
				break;
		}
		exit(EXIT_SUCCESS);
	}
 
	wait(NULL);
 
	return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/403008.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

在Shopee 平台上销售露营用品的策略指南

在Shopee 平台上销售露营用品的策略指南

在当今数字化时代&#xff0c;电商平台成为了许多商家推广产品的首选渠道。对于想要在 Shopee 平台上销售露营用品的卖家来说&#xff0c;制定有效的选品策略至关重要。通过市场调研、热销品类分析、竞品分析、产品差异化等一系列策略&#xff0c;卖家可以提高产品的竞争力和销…
阅读更多...
程序员可以做哪些副业？

程序员可以做哪些副业？

如果你经常玩知乎、看公众号&#xff08;软件、工具、互联网这几类的&#xff09;你就会发现&#xff0c;好多资源连接都变成了夸克网盘、迅雷网盘的资源链接。 例如&#xff1a;天涯神贴&#xff0c;基本上全是夸克、UC、迅雷网盘的资源链接。 有资源的前提下&#xff0c;迅雷…
阅读更多...
【大数据】Flink 之部署篇

【大数据】Flink 之部署篇

Flink 之部署篇 1.概述和参考架构2.可重复的资源清理3.部署模式3.1 Application 模式3.2 Per-Job 模式&#xff08;已废弃&#xff09;3.3 Session 模式 Flink 是一个多用途框架&#xff0c;支持多种不同的混合部署方案。下面&#xff0c;我们将简要介绍 Flink 集群的构建模块、…
阅读更多...
电阻知识详解

电阻知识详解

基本介绍 电阻阻碍电流流动&#xff1a;只要有电流流过电阻&#xff0c;就会产生功率损耗 基本单位&#xff1a;欧姆&#xff0c;Ω 换算单位&#xff1a;微欧&#xff08;uΩ&#xff09;、毫欧&#xff08;mΩ&#xff09;、千欧&#xff08;kΩ&#xff09;、兆欧&#x…
阅读更多...
简单实现节流函数踩的小坑

简单实现节流函数踩的小坑

平时debounce&#xff08;防抖&#xff09;用得多&#xff0c;throttle用得少&#xff0c;记下写 throttle 时遇到的低级错误。 节流&#xff0c;一定时间内多次操作&#xff0c;在最早操作的若干延迟后执行。 场景参考&#xff1a;周期上报&#xff0c;有的数据不急着报&#…
阅读更多...
week04day03(爬虫 beautifulsoup4、)

week04day03(爬虫 beautifulsoup4、)

一. 使用bs4解析网页 下载bs4 - pip install beautifulsoup4 使用的时候 import bs4专门用于解析网页的第三方库 在使用bs4的时候往往会依赖另一个库lxml pip install lxml 网页代码 <!DOCTYPE html> <html><head><meta charset"utf-8"><…
阅读更多...
什么是测试？测试测什么？

什么是测试？测试测什么？

笔者是软件测试方向的硕士研究生。作为应届生拿下了20余个软件测试、测试开发的offer。 《校招生如何准备测试》系列会将我的测试理论体系与大家分享、探讨和学习。本期主要串联一下什么是测试、软件测试测什么&#xff08;测试类型&#xff09;。 Q&#xff1a;什么是软件测…
阅读更多...
（十三）【Jmeter】线程（Threads(Users)）之tearDown 线程组

（十三）【Jmeter】线程（Threads(Users)）之tearDown 线程组

简述 操作路径如下： 作用：在正式测试结束后执行清理操作，如关闭连接、释放资源等。配置：设置清理操作的采样器、执行顺序等参数。使用场景：确保在测试结束后应用程序恢复到正常状态，避免资源泄漏或对其他测试的影响。优点：提供清理操作，确保测试环境的整洁和可重复性…
阅读更多...
铭瑄科技——为星闪技术发展与应用带来新推力

铭瑄科技——为星闪技术发展与应用带来新推力

随着智能化生活逐渐普及&#xff0c;无线通信不仅是不仅是信息时代的重要基础设施&#xff0c;而且是推动社会向智能化发展的核心力量之一&#xff0c;其中短距无线通信更是推动未来智能化发展的关键。 为积极推动未来硬件智能化、产业智能化发展&#xff0c;铭瑄正式宣布成为星…
阅读更多...
Codeforces Round 928 (Div. 4)

Codeforces Round 928 (Div. 4)

目录 A. Vlad and the Best of Five B. Vlad and Shapes C. Vlad and a Sum of Sum of Digits D. Vlad and Division E. Vlad and an Odd Ordering F. Vlad and Avoiding X G. Vlad and Trouble at MIT A. Vlad and the Best of Five 我们可以使用string中的count函数来…
阅读更多...
《VitePress 简易速速上手小册》第8章 安全性与部署（2024 最新版）

《VitePress 简易速速上手小册》第8章 安全性与部署（2024 最新版）

文章目录 8.1 安全最佳实践8.1.1 基础知识点解析8.1.2 重点案例&#xff1a;个人博客8.1.3 拓展案例 1&#xff1a;在线商店8.1.4 拓展案例 2&#xff1a;企业网站 8.2 部署到 GitHub Pages 和其他平台8.2.1 基础知识点解析8.2.2 重点案例&#xff1a;个人博客部署到 GitHub Pa…
阅读更多...
时序预测demo 代码快速实现 MLP效果比LSTM 好，简单模拟数据

时序预测demo 代码快速实现 MLP效果比LSTM 好，简单模拟数据

【PyTorch修炼】用pytorch写一个经常用来测试时序模型的简单常规套路&#xff08;LSTM多步迭代预测&#xff09; 层数的理解&#xff1a; LSTM&#xff08;长短期记忆&#xff09;的层数指的是在神经网络中堆叠的LSTM单元的数量。层数决定了网络能够学习的复杂性和深度。每一层…
阅读更多...
SQL- left join 与group by联合使用实例

SQL- left join 与group by联合使用实例

表&#xff1a;Visits ---------------------- | Column Name | Type | ---------------------- | visit_id | int | | customer_id | int | ---------------------- visit_id 是该表中具有唯一值的列。 该表包含有关光临过购物中心的顾客的信息。表&#xff1a…
阅读更多...
Docker容器与虚拟化技术：kylin 部署 docker容器应用

Docker容器与虚拟化技术：kylin 部署 docker容器应用

目录 一、实验 1.环境 2. kylin 部署 docker及版本升级 3.kylin 部署docker镜像加速 4.kylin 部署 nginx容器应用 5.kylin使用docker容器部署mysql实现数据持久化 6.kylin使用docker容器部署nginx实现配置文件持久化到本地 7.kylin 使⽤ docker 部署容器可视化平台porta…
阅读更多...
【青龙】快速搭建青龙面板，部署属于你自己的应用！

【青龙】快速搭建青龙面板，部署属于你自己的应用！

青龙面板是一个支持 Python3、JavaScript、Shell、Typescript 的定时任务管理平台。 废话不多说&#xff0c;直接开始。 这里使用一台 雨云 的云服务器作为演示。雨云注册地址&#xff1a;https://www.rainyun.com/ 优惠码&#xff1a;lz932 使用优惠码注册后绑定微信可获得8折…
阅读更多...
Spring框架@Autowired注解进行字段时，使用父类类型接收子类变量，可以注入成功吗？（@Autowired源码跟踪）

Spring框架@Autowired注解进行字段时，使用父类类型接收子类变量，可以注入成功吗？（@Autowired源码跟踪）

一、 前言 平常我们在使用spring框架开发项目过程中&#xff0c;会使用Autowired注解进行属性依赖注入&#xff0c;一般我们都是声明接口类型来接收接口实现变量&#xff0c;那么使用父类类型接收子类变量&#xff0c;可以注入成功吗&#xff1f;答案是肯定可以的&#xff01;…
阅读更多...
从零学习Linux操作系统第二十七部分 shell脚本中的变量

从零学习Linux操作系统第二十七部分 shell脚本中的变量

一、什么是变量 变量的定义 定义本身 变量就是内存一片区域的地址 变量存在的意义 命令无法操作一直变化的目标 用一串固定的字符来表示不固定的目标可以解决此问题 二、变量的类型及命名规范 环境级别 export A1 在环境关闭后变量失效 退出后 关闭 用户级别&#xff…
阅读更多...
Java项目：24 基于SpringBoot+freemarker实现的人事管理系统

Java项目：24 基于SpringBoot+freemarker实现的人事管理系统

作者主页&#xff1a;源码空间codegym 简介&#xff1a;Java领域优质创作者、Java项目、学习资料、技术互助 文中获取源码 项目介绍 基于SpringBootfreemarker实现的人事管理系统分为七大模块&#xff1a;绩效考核&#xff0c;招聘管理&#xff0c;档案管理&#xff0c;工资管…
阅读更多...
Marin说PCB之如何使用mentor--xpedition-Valor软件做gerber_compare

Marin说PCB之如何使用mentor--xpedition-Valor软件做gerber_compare

首先打开mentro_xpedition,自带的Valor软件。 2&#xff0c;在File栏中选择import---odb。 3&#xff0c;导入生成的DOB文件。 4&#xff0c;在这个界面下再重新导入一份之前的参考板的ODB文件进来。 5&#xff0c;接着点击STEPS---board,这样单板的数据就被调进来了。 6&#…
阅读更多...
《剑指Offer》笔记题解思路技巧优化_Part_6

《剑指Offer》笔记题解思路技巧优化_Part_6

《剑指Offer》笔记&题解&思路&技巧&优化_Part_6 &#x1f60d;&#x1f60d;&#x1f60d; 相知&#x1f64c;&#x1f64c;&#x1f64c; 相识&#x1f622;&#x1f622;&#x1f622; 开始刷题&#x1f7e1;1.LCR 168. 丑数—— 丑数&#x1f7e2;2. LCR 16…
阅读更多...
最新文章

Copyright @ 2022~2023