IO进程线程day5

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

#include 

char buf[128];//全局数组，临界资源
//1.定义一个锁
pthread_mutex_t mutex;
void *task(void *arg)
{
	while(1)
	{
	//获取锁资源
	pthread_mutex_lock(&mutex);
	printf("我是分线程:buf=%s\n",buf);
	strcpy(buf,"hahahaha\n");
	//释放锁资源
	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\n");
		return -1;
	}
	//主线程
	while(1)
	{
		//3.上锁，获取锁资源
		pthread_mutex_lock(&mutex);
		printf("我是主线程：buf=%s\n",buf);
		strcpy(buf,"hello\n");
		//4.解锁，释放锁资源
		pthread_mutex_unlock(&mutex);
		
	}
	//阻塞回收线程资源
	pthread_join(tid,NULL);
	//销毁锁资源
	pthread_mutex_destroy(&mutex);
	
	return 0;
}

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

#include 
//1.创建一个无名信号量
sem_t sem;

void *task1(void *arg)
{
	while(1)
	{
		sleep(1);
		printf("我是你爹\n");
		//释放资源
		sem_post(&sem);

	}
}
void * task2(void *arg)
{
	while(1)
	{
		//申请资源
		sem_wait(&sem);
		printf("啊 对对对\n");
		
	}
}

int main(int argc, const char *argv[])
{
	//创建两个进程
	pthread_t tid1,tid2;
	//2.对无名信号量进行初始化
	sem_init(&sem,0,0);
	//第一个0表示线程之间的通信
	//第二个0表示value初始值为0
	if(pthread_create(&tid1,NULL,task1,NULL))
	{
		printf("tid1 create error\n");
		return -1;
	}
	if(pthread_create(&tid2,NULL,task2,NULL))
	{
		printf("tid2 create error");
		return -1;
	}
	//回收资源
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);

	//销毁无名信号量
	sem_destroy(&sem);
	

	return 0;
}

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

#include 

struct info
{
	const char *srcfile;
//	int len=size/2;
	const char *destfile;
	int size;
//	int halfsize;
};
int get_file_size(const char *srcfile,const char *destfile)
{
	//定义两个文件描述符
	int srcfd=-1;
	int destfd=-1;;
	//分别打开两个文件
	if((srcfd=open(srcfile,O_RDONLY))==0)
	{
		printf("open srcfile error1");
		return -1;
	}
	if((destfd=open(destfile,O_WRONLY|O_CREAT|O_TRUNC,0664))==0)
	{
		printf("open destfile error2");
		return -1;
	}
	
	int size=lseek(srcfd,0,SEEK_END);

	//关闭文件描述符
	close(srcfd);
	close(destfd);
	return size;
}
//copy功能构建
int copy_file(const char *srcfile,const char *destfile,int size,int start)
{
	//定义两个文件描述符
	int srcfd=-1;
	int destfd=-1;;
	//分别打开两个文件
	if((srcfd=open(srcfile,O_RDONLY))==-1)
	{
		printf("open srcfile error3");
		return -1;
	}
	if((destfd=open(destfile,O_WRONLY))==-1)
	{
		printf("open destfile error4");
		return -1;
	}
	//将两个文件同时定位到start处
	lseek(srcfd,start,SEEK_SET);
	lseek(destfd,start,SEEK_SET);

	
	//循环读写
	char buf[128]="";
	int res=0;//每次成功读取的数据个数
	int sum=0;//记录每次成功读取的总数据个数
	while(1)
	{
		int res=read(srcfd,buf,sizeof(buf));
		sum+=res;
		if(res==0||sum>=size)
		{
			write(destfd,buf,res-(sum-size));
			break;
		}
		write(destfd,buf,res);

	}
	
	//关闭文件描述符
	close(srcfd);
	close(destfd);
	return 0;
}

//第一个分支线程完成拷贝前半部分
void *task1(void *arg)
{
	struct info *f=(struct info *)arg;
	copy_file(f->srcfile,f->destfile,\
			f->size/2,0);
	pthread_exit(NULL);
}


//第二个分支前程拷贝后半部分
void *task2(void *arg)
{
	struct info *f=(struct info *)arg;
	copy_file(f->srcfile,f->destfile,\
			f->size-(f->size/2),f->size/2);
	pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
	//判断外部传参个数
	if(argc!=3)
	{
		printf("input file error");
		return -1;
	}
	//计算源文件大小
	int size=get_file_size(argv[1],argv[2]);
	//创建结构体变量并对其初始化
//	struct info buf=(struct info *)malloc(sizeof(struct info));
	struct info buf={argv[1],argv[2],size};

	//定义两个线程号变量
	pthread_t tid1,tid2;
	//创建两个线程
	if(pthread_create(&tid1,NULL,task1,&buf)!=0)
	{
		printf("tid1 create error1");
		return -1;
	}
	if(pthread_create(&tid2,NULL,task2,&buf)!=0)
	{
		printf("tid2 create error2");
		return -1;
	}
	

	//回收线程
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	//释放内存
//	free(buf);
//	buf=NULL;
	printf("copy success!\n");
	return 0;
}

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

#include 

//创建一个无名信号量
sem_t sem,sem1,sem2;
//no.1
void *task1(void *arg)
{
	while(1)
	{
		sem_wait(&sem);
			sleep(1);
		//释放资源
		printf("A");
		fflush(stdout);
		sem_post(&sem1);
	}
}
//no.2
void *task2(void *arg)
{
	while(1)
	{
		
		//申请资源
		sem_wait(&sem1);
		printf("B");
		fflush(stdout);
		//释放资源
		sem_post(&sem2);
	}
}
//no.3
void *task3(void *arg)
{
	while(1)
	{
		sem_wait(&sem2);
		printf("C");
		fflush(stdout);
	//	sleep(1);
		sem_post(&sem);
	}
}


int main(int argc, const char *argv[])
{
	//创建3个线程
	pthread_t tid1,tid2,tid3;
	//初始化无名信号量
	sem_init(&sem,0,1);
	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 error\n");
		return -1;
	}
	//创建三号线程
	if(pthread_create(&tid3,NULL,task3,NULL)!=0)
	{
		printf("tid3 create error\n");
		return -1;
		}

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

	//销毁无名信号量