IO作业5.0

思维导图

1> 将互斥机制代码重新实现一遍

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <myhead.h>
char buf[128]; 		//全局数组，临街资源
//1、创建互斥锁
pthread_mutex_t mutex;
//定义分支线程
void *task(void *arg)
{
	while(1)
	{
		//3、获取锁资源
		pthread_mutex_lock(&mutex);

		printf("分支线程中:buf = %s\n", buf);
		strcpy(buf,"I love china\n");

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

	}
}
int main(int argc, const char *argv[])
{
	//定义线程变量
	pthread_t tid;

	//2、初始化互斥锁
	pthread_mutex_init(&mutex,NULL);

	//创建线程
	if(pthread_create(&tid, NULL, task, NULL) != 0)
	{
		printf("tid create error");
		return -1;	
	}
	
	//主线程
	while(1)
	{
		//3、获取锁资源
		pthread_mutex_lock(&mutex);

		printf("主线程中:buf = %s\n", buf);
		strcpy(buf,"hello world\n");

	
		//4、释放锁资源
		pthread_mutex_unlock(&mutex);	
	
	}
	
	//阻塞回收线程资源
	pthread_join(tid ,NULL);
	
	//5、销毁锁资源
	pthread_mutex_destroy(&mutex);

	return 0;
}

2> 将同步机制代码重新实现一遍

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <myhead.h>
//创建一个无名信号量
sem_t sem;
//生产者线程
void *task(void *arg)
{
	while(1)
	{
		sleep(2);
		printf("我生产了一辆大众\n");

		//释放资源
		sem_post(&sem);

	}
}
//消费者线程
void *task1(void *arg)
{
	while(1)
	{
		//申请资源，如果没有则堵塞
		sem_wait(&sem);

		printf("我消费了一辆大众\n");
	}
}
int main(int argc, const char *argv[])
{
	//创建两个线程
	pthread_t tid1,tid2;
	//初始化无名信号量
	sem_init(&sem,0,0);//第一个0表示线程通信，第二个0表示value初始值为0
	//创建生产者线程
	if(pthread_create(&tid1,NULL,task,NULL) != 0)
	{
		printf("tid1 create error\n");
		return -1;
	}
	//创建消费者线程
	if(pthread_create(&tid2,NULL,task1,NULL) != 0)
	{
		printf("tid2 create error\n");
		return -1;
	}
	//主线程回收资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	//销毁无名信号量
	sem_destroy(&sem);



	return 0;
}

3> 使用三个线程完成两个文件的拷贝，线程1完成拷贝前一半，线程2完成拷贝后一半，主线程回收两个分支线程的资源

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <myhead.h>
struct Node
{
	const char *rid1; //读取的文件
	const char *wid2; //写入的文件
	int start; //开始的位置
	int len; //长度
};

//定义长度
int lenstr(const char *r,const char *w)
{
	//以只读的形式打开源文件
	FILE *rfp=NULL;
	if((rfp=fopen(r,"r"))==NULL)
	{
		perror("rfp error");
		return -1;
	}
	//以只写的形式打开目标文件
	FILE *rfq=NULL;
	if((rfq=fopen(w,"r"))==NULL)
	{
		perror("rfq error");
		return -1;
	}
	int len=0;    //计数	
	fseek(rfp,0,SEEK_END);	//光标偏移到文件最后的位置
	len=ftell(rfp);   //返回值就是文件的数量
	fclose(rfp); 	//关闭文件
	fclose(rfq); 	//关闭文件
	return len;
}
//拷贝函数
int copy(const char *r1,const char *w2,int start,int len)
{
	//定义文件指针
	FILE *fid1=NULL;
	if((fid1=fopen(r1,"r"))==NULL)
	{
		perror("fid1 error");
		return -1;
	}
	//定义文件指针
	FILE * fid2=NULL;
	if((fid2=fopen(w2,"a"))==NULL)
	{
		perror("fid2 error");
		return -1;
	}
	//定义文件搬运工
	char buf[128]="";
	fseek(fid1,start,SEEK_SET);
	fseek(fid2,start,SEEK_SET);
	int count=fread(buf,1,sizeof(buf),fid1);
	fwrite(buf,1,count,fid2);
	//关闭文件
	fclose(fid1);
	fclose(fid2);
	return 0;
}
void *task1(void *arg)
{
	while(1)
	{
		struct Node *head=(struct Node *)arg;
		//调用拷贝函数
		copy(head->rid1,head->wid2,head->start,head->len);
		printf("我是分支线程1\n");
		sleep(1);
		//退出当前线程
		printf("分支线程1退出\n");
		pthread_exit(NULL);
	}
}
void *task2(void *arg)
{
	while(1)
	{
		printf("我是分支线程2\n");
		sleep(1);
		struct Node *head=(struct Node *)arg;
		//调用拷贝函数
		copy(head->rid1,head->wid2,head->start,head->len);
		//退出当前线程
		printf("分支线程2退出\n");
		pthread_exit(NULL);
	}
}

int main(int argc, const char *argv[])
{
	if(argc != 3)	
	{
		printf("Presentation Error\n");
		return -1;
	}
	//计算文件大小
	int len = lenstr(argv[1],argv[2]);
	//定义结构体变量
	struct Node t1={argv[1],argv[2],0,len/2};
	struct Node t2={argv[1],argv[2],len/2,len-len/2}; 
	//创建两个线程
	pthread_t tid1=0,tid2=0;
	if(pthread_create(&tid1,NULL,task1,&t1)!=0)
	{
		printf("tid1 error\n");
		return -1;
	}
	if(pthread_create(&tid2,NULL,task2,&t2)!=0)
	{
		printf("tid2 error\n");
		return -1;
	}
	
	printf("我是主线程\n");
	sleep(2);

	//回收线程
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	printf("主线程成功回收分支线程的资源\n");
	printf("拷贝成功\n");

	return 0;
}

4> 使用三个线程完成：线程1输出字符'A',线程2输出字符'B',线程3输出字符'C',要求输出结果为：ABCABCABCABCABC...

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <myhead.h>
//创建无名信号量
sem_t sem1,sem2;
//A
void *task1(void *arg)
{
	while(1)
	{
		sleep(1);
		printf("A");
		//释放
		sem_post(&sem1);
	}
}
//B
void *task2(void *arg)
{
	while(1)
	{	
		sem_wait(&sem1);//申请资源，没有则堵塞
		printf("B");
		//释放
		sem_post(&sem2);
	}
}
//C
void *task3(void *arg)
{
	while(1)
	{	
		sem_wait(&sem2);//申请资源，没有则堵塞
		printf("C");
		fflush(stdout);//刷新缓冲区
	}
}
int main(int argc, const char *argv[])
{
	//创建三个线程
	pthread_t tid1,tid2,tid3;
	//初始化
	sem_init(&sem1,0,0);
	sem_init(&sem2,0,0);
	//创建线程
	if(pthread_create(&tid1,NULL,task1,NULL)!=0)
	{
		printf("tid1 create error\n");
		return -1;
	}
	if(pthread_create(&tid2,NULL,task2,NULL)!=0)
	{
		printf("tid2 create\n");
		return -1;
	}
	if(pthread_create(&tid3,NULL,task3,NULL)!=0)
	{
		printf("tid3 create\n");
		return -1;
	}
	//主线程回收资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	pthread_join(tid3,NULL);
	//销毁无名信号量
	sem_destroy(&sem1);
	sem_destroy(&sem2);
	return 0;
}