IO进程线程day6

  • 开发
  • 24

思维导图：

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

阅读全部

相关推荐

  1. 23111 IO进程线程 day6

    2024-02-23 10:00:05       36 阅读

  9. IO进程线程 day7

    2024-02-23 10:00:05       38 阅读

最近更新

  4. TCP协议是安全的吗?

    2024-02-23 10:00:05       18 阅读

  12. 阿里云服务器执行yum，一直下载docker-ce-stable失败

    2024-02-23 10:00:05       19 阅读

  13. 【Python教程】压缩PDF文件大小

    2024-02-23 10:00:05       18 阅读

  18. 通过文章id递归查询所有评论（xml）

    2024-02-23 10:00:05       20 阅读

热门阅读

  1. 技术心得--如何成为优秀的架构师

    2024-02-23 10:00:05       32 阅读

  7. Flutter学习5 - Dart 方法类型

    2024-02-23 10:00:05       28 阅读

  9. 滴滴二面：kafka的零拷贝原理?

    2024-02-23 10:00:05       23 阅读

  12. 进程间传递 SQL 文的方法

    2024-02-23 10:00:05       32 阅读

  14. 微信小程序中预览文档不同平台全文档的兼容处理

    2024-02-23 10:00:05       24 阅读

  18. 【深度学习】Gemini 1.0 Pro 如何让chatGPT扮演stable diffusion的提示词工程师

    2024-02-23 10:00:05       32 阅读

  28. 开源图表库Echarts 简介与基本使用

    2024-02-23 10:00:05       29 阅读

  29. gitlab 忘记root密码，修改root密码

    2024-02-23 10:00:05       25 阅读

  30. 前端简单复习

    2024-02-23 10:00:05       25 阅读