230531

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

typedef struct shuzhu
{
	int arg1;
	int arg2;
	int start;
	int len;
}jgt;

int get_len(const char *srcfile, const char *destfile)
{
    //定义两个文件描述符
    int fd1, fd2;

    //以只读的形式打开第一个文件
    if((fd1=open(srcfile, O_RDONLY)) == -1)
    {
        perror("open srcfile error");
        return -1;
    }

    //以读写的形式打开文件
    if((fd2 = open(destfile, O_RDWR|O_CREAT|O_TRUNC, 0664)) == -1)
    {
        perror("open destfile error");
        return -1;
    }

    //求源文件的大小
    int len = lseek(fd1, 0, SEEK_END);

    //关闭两个文件
    close(fd1);
    close(fd2);

    return len;
}

//定义拷贝函数
int copy_file( int a,int b, int start, int len)
{
    //定义两个文件描述符
    int fd1, fd2;

    fd1=a;
	fd2=b;
    //定位两个文件的光标
    lseek(fd1, start, SEEK_SET);
    lseek(fd2, start, SEEK_SET);

    //拷贝工作
    char buf[128] = "";          //内容搬运工
    int ret = 0;
    int count = 0;        //记录读取的个数

    while(1)
    {
		buf[128]='\0';
        //从源文件中读取数据
        ret = read(fd1, buf, sizeof(buf));
        count += ret;               //将读取的个数累加
        
        if(ret == 0 || count > len)
        {
            write(fd2, buf, ret - (count-len));    //最后一次写操作
            
            break;
        }

        //将读取下来的内容写到新文件中去
        write(fd2, buf, ret);
    }

    //close(fd1);
    //close(fd2);

    return 0;
}



void *task1(void *arg)
{
	//pthread_mutex_lock(&mutex);
	printf("hasd\n");	
	//  copy_file(argv[1], argv[2], 0, len/2);
	jgt *gr=arg;
	int a=gr->arg1;
	int b=gr->arg2;
	printf("asjd\n");
	int c=gr->start;
	int d=gr->len;
	printf("%d %d %d %d __%d__\n",a,b,c,d, __LINE__);
	copy_file(a, b, c, d);

	printf("1\n");
	//pthread_mutex_unlock(&mutex);
	pthread_exit(NULL);

}
void *task2(void *arg)
{

	

	//pthread_mutex_lock(&mutex);
	jgt *grg=arg;
	int a=grg->arg1;
	int b=grg->arg2;
	int c=grg->start;
	int d=grg->len;
	printf("%d %d %d %d __%d__\n",a,b,c,d, __LINE__);
	copy_file(a, b, c, d);

	printf("2\n");
	sleep(1);
	//pthread_mutex_unlock(&mutex);
	pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
			
	if(argc != 3)
    {
        printf("input file error\n");
        printf("usage:./a.out srcfile destfile\n");
        return -1;
    }
	 int len = get_len(argv[1], argv[2]);
	//定义两个文件描述符=====================================================
    int fd1, fd2;

    //以只读的形式打开第一个文件
    if((fd1=open(argv[1], O_RDONLY)) == -1)
    {
        perror("open srcfile error");
        return -1;
    }

    //以读写的形式打开文件
    if((fd2 = open(argv[2], O_RDWR)) == -1)
    {
        perror("open destfile error");
        return -1;
    }
	jgt a={fd1,fd2,0,len/2};
	jgt b={fd1,fd2,len/2,len-len/2};
	//struct shuzhu jgt.srcfile=argv[1];
	//jgt1={.srcfile =argv[1],.destfile=argv[2],.start=len/2,.len=len/2};
//	close(fd1);
//	close(fd2);

	pthread_t tid1,tid2;
	if(pthread_create(&tid1,NULL,task1,&a))
	{
		perror("");
		return -1;
	}


	
	if(pthread_create(&tid2,NULL,task2,&b))
	{
		perror("");
		return -1;
	}
	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	pthread_mutex_destroy(&mutex);
	close(fd1);
	close(fd2);

	return 0;
}