IO作业day5

1> 使用两个线程完成两个文件的拷贝，主线程拷贝前一半内容，子线程拷贝后一半内容，并且主线程要阻塞回收子线程资源

2> 使用三个进程完成两个文件的拷贝，主线程拷贝前三分之一，子线程1拷贝中间三分之一，子线程2拷贝后三分之一，主线程要设置两个子线程为分离态

1：

#include <myhead.h>
struct Node
{
	const char *srcfile;
	const char *dstfile;
	int stat;
	int len;
};
//获取文件大小函数
int getlen(const char *srcfile, const char *dstfile)
{
	int fd1,fd2;
	//以只写形式打开源文件
	if((fd1=open(srcfile,O_RDONLY)) == -1)
	{
		perror("srcfile open error");
		return -1;
	}

	if((fd2=open(dstfile, O_WRONLY|O_CREAT|O_TRUNC, 0664)) == -1)
	{
		perror("dstfile open error");
		return -1;
	}
	//求源文件的长度
	int len = lseek(fd1,0,SEEK_END);
	close(fd1);
	close(fd2);
	return len;
}
//拷贝文件函数
void copy_file(const char *srcfile, const char *dstfile, int start, int len)
{
	int fd1,fd2;
	if((fd1=open(srcfile,O_RDONLY)) == -1)
	{
		perror("srcfile open error");
		return ;
	}
	if((fd2=open(dstfile,O_WRONLY)) == -1)
	{
		perror("dstfile open error");
		return ;
	}
	//将光标移动至开始拷贝的位置
	lseek(fd1,start,SEEK_SET);
	lseek(fd2,start,SEEK_SET);
	//开始拷贝
	char buf[100]="";
	int sum=0;

	while(1)
	{
		int ret = read(fd1, buf, sizeof(buf));
		sum += ret;

		if(ret == 0 || sum > len)
		{
			write(fd2, buf, ret-(sum-len));
			break;
		}
		write(fd2, buf, ret);
	}
	printf("拷贝成功\n");
}
//线程1
void *task1(void *arg)
{
	//解压结构体数据
	struct Node File = *(struct Node*)arg;
	//调用拷贝函数复制后一半文件
	copy_file(File.srcfile, File.dstfile, File.stat, File.len);
	pthread_exit(NULL);//退出当前线程
}

int main(int argc, const char *argv[])
{	
	//判断传入文件个数
	if(argc != 3)
	{
		printf("input file error\n");
		printf("usage:./a.out srcfile dstfile\n");
		return -1;
	}
	//获取文件大小
	int len = getlen(argv[1],argv[2]);

	//定义结构体变量
	struct Node cpy_file1 = {argv[1], argv[2], len/2, len-len/2};

	pthread_t tid;//创建线程

	if(pthread_create(&tid,NULL,task1,&cpy_file1))
	{
		printf("线程创建失败\n");
		return -1;
	}	
	//调用拷贝函数拷贝前一半文件
	 copy_file(argv[1], argv[2],0 ,len/2);
	 //阻塞回收线程1资源
	 pthread_join(tid,NULL);
	return 0;
}

结果：

 2：

#include <myhead.h>

//定义结构体
struct Node
{
	const char *srcfile;
	const char *dstfile;
	int stat;
	int len;
};

//定义获取文件大小函数
int getlen(const char *srcfile, const char *dstfile)
{
	//定义两个文件指针
	FILE *srcfp, *dstfp;
	if((srcfp=fopen(srcfile,"r")) == NULL)
	{
		perror("srcfile open error");
		return -1;
	}
	if((dstfp=fopen(dstfile,"w")) == NULL)
	{
		perror("dstfile open error");
		return -1;
	}
	//求源文件大小
	fseek(srcfp, 0, SEEK_END);
	int len = ftell(srcfp);

	return len;
}

//定义拷贝文件函数
void copy_file(const char *srcfile, const char *dstfile, int start, int len)
{
	FILE *srcfp, *dstfp;
	if((srcfp=fopen(srcfile,"r")) == NULL)
	{
		perror("srcfile open error");
		return ;
	}
	if((dstfp=fopen(dstfile,"w")) == NULL)
	{
		perror("dstfile open error");
		return ;
	}
	//将光标移动至开始拷贝的位置
	fseek(srcfp, start, SEEK_SET);
	fseek(dstfp, start, SEEK_SET);
	char buf;
	int sum = 0;

	while(ftell(srcfp) != (len))
	{
		buf = fgetc(srcfp);
		fputc(buf, dstfp);
	}
	printf("拷贝成功\n");
}
void *task1(void *arg)
{
	//printf("1");
	sleep(2);
	struct Node cp = *(struct Node*)arg;
	copy_file(cp.srcfile, cp.dstfile, cp.stat, cp.len);
	pthread_exit(NULL);
}
void *task2(void *arg)
{
	//printf("2");
	sleep(4);
	struct Node cp = *(struct Node *)arg;
	copy_file(cp.srcfile, cp.dstfile, cp.stat, cp.len);

	pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
	//判断传入文件个数
	if(argc != 3)
	{
		printf("input file error\n");
		printf("usage:./a.out srcfile dstfile\n");
		return -1;
	}
	//获取文件大小
	int len = getlen(argv[1],argv[2]);
	struct Node cp_file1={argv[1], argv[2], len/3, len*2/3 };
	//定义子线程1
	pthread_t tid1;
	if(pthread_create(&tid1, NULL, task1, &cp_file1))
	{
		printf("线程创建失败\n");
		return -1;
	}
	pthread_t tid2;
	struct Node	cp_file2={argv[1], argv[2], len*2/3, len };
	if(pthread_create(&tid2, NULL, task2, &cp_file2))
	{
		printf("线程创建失败\n");
		return -1;
	}
	copy_file(argv[1], argv[2], 0, len/3);
	sleep(6);
	pthread_detach(tid1);	
	pthread_detach(tid2);
	return 0;
}

结果：

 

思维导图：