多进程和多线程文件拷贝

1. 线程与进程的异同点

A.相同点

1): 比如都有自己在系统中唯一标识ID,一组寄存器(pc指针 )，状态（6种），调度优先级以及所要遵循的调度策略。

2): 每个进程都有一个进程控制块，线程也拥有一个线程控制块(在Linux内核，线程控制块与进程控制块用同一个结构体描述,即struct task_struct)，这个控制块包含线程的一些属性信息，操作系统使用这些属性信息来描述线程。

3): 线程和子进程的创建者可以在线程和子进程上实行某些控制，比如，创建者可以取消、挂起、继续和修改线程和子进程的优先级。

B.不同点

1): 主要区别：每个进程都拥有自己的地址空间，但线程没有自己独立的地址空间,但是线程栈是线程专属的，而是运行在一个进程里的所有线程共享该进程的整个虚拟地址空间。

2): 线程的上下文切换时间开销比进程上下文切换时间开销要小的多

3): 线程的创建开销远远小于进程的创建

4): 子进程拥有父进程的地址空间和数据段的拷贝，因此当子进程修改它的变量和数据时，它不会影响父进程中的数据，但线程可以直接访问它进程中的数据段。

5): 进程之间通讯必须使用进程间通讯机制，但线程可以与进程中的其他线程直接通讯

6): 线程可以对同一进程中的其他线程实施大量控制，但进程只能对子进程实施控制

7): 改变主线程的属性可能影响进程中其他的线程，但对父进程的修改不影响子进程

2. 多进程文件拷贝程序：

<pre name="code" class="cpp">#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

int copy_file_init(const char *src_file,const char *dest_file)
{
	int fd_src;
	int fd_dest;
	int src_file_len;
	
	fd_src = open(src_file,O_RDONLY);
	if(fd_src < 0){
		fprintf(stderr,"Fail to open %s : %s\n",src_file,strerror(errno));
		exit(EXIT_FAILURE);
	}

	src_file_len = lseek(fd_src,0,SEEK_END);

	fd_dest = open(dest_file,O_WRONLY | O_TRUNC | O_CREAT,0666);
	if(fd_dest < 0){
		fprintf(stderr,"Fail to open %s : %s\n",dest_file,strerror(errno));
		exit(EXIT_FAILURE);
	}
	
	close(fd_src);
	close(fd_dest);

	return src_file_len;
}

int copy_file(const char *src_file,const char *dest_file,int postion,int len)
{
	int n;
	int fd_src;
	int fd_dest;
	int count = 0;
	char buf[1024];

	fd_src = open(src_file,O_RDONLY);
	if(fd_src < 0){
		fprintf(stderr,"Fail to open %s : %s\n",src_file,strerror(errno));
		exit(EXIT_FAILURE);
	}

	fd_dest = open(dest_file,O_WRONLY);
	if(fd_dest < 0){
		fprintf(stderr,"Fail to open %s : %s\n",dest_file,strerror(errno));
		exit(EXIT_FAILURE);
	}

	lseek(fd_src,postion,SEEK_SET);
	lseek(fd_dest,postion,SEEK_SET);
	
	while(1){
		n = read(fd_src,buf,sizeof(buf));
		if(n <= 0){
			break;
		}
		
		n = write(fd_dest,buf,n);
		if(n <= 0){
			break;
		}

		count += n;

		if(count >= len){
			break;
		}
	}
	
	close(fd_src);
	close(fd_dest);

	return count;
}

void process_copy_file(const char *src_file,const char *dest_file,int src_file_len,int precess_num)
{
	int n;
	int m=0;
	pid_t pid;

	pid = fork();
	if(pid < 0){
		perror("Fail to fork");
		exit(EXIT_FAILURE);
	}

	if(pid == 0){
		n = copy_file(src_file,dest_file,src_file_len/2,(src_file_len - src_file_len / 2));
		printf("Child process copy %d bytes!\n",n);
	}

	if(pid > 0){
		n = copy_file(src_file,dest_file,0,src_file_len / 2);
		printf("Parent process copy %d bytes!\n",n);
	}
	
	while(precess_num > 0){
		pid = fork();
		if(pid < 0){
			perror("Fail to fork");
			exit(EXIT_FAILURE);
		}
		else{
			n--;
		}
		if
	}
	
	return ;
}

//./a.out src_file dest_file
int main(int argc, const char *argv[])
{
	int src_file_len;

	if(argc < 3){
		fprintf(stderr,"Usage : %s <src file> <dest file>!\n",argv[0]);
		exit(EXIT_FAILURE);
	}

	src_file_len = copy_file_init(argv[1],argv[2]);
	process_copy_file(argv[1],argv[2],src_file_len);
	exit(EXIT_SUCCESS);
		
}

3. 多线程文件拷贝程序：

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>


//pthread_mutex_t lock;
struct args{
char src_file[128];
char des_file[128];
int position;
int len;
};


int get_filelen(const char *src_file)
{
int len; 
FILE *fp;
fp = fopen(src_file,"r");
fseek(fp,0,SEEK_END);
len = ftell(fp);
rewind(fp);
return len;
}


void init_args(struct args *args ,const char *src_file,const char *des_file,int pos,int len)
{
strcpy(args->src_file, src_file);
strcpy(args->des_file, des_file);
args->position = pos;
args->len = len;
}


void *copy_file(void *arg)
{
// pthread_mutex_lock(&lock);
int n = 0;
int ret;
int count = 0;
int read_len = 0;
char buf[4096];
FILE *fp1,*fp2;
struct args *p = (struct args*)arg;
fp1 = fopen(p->src_file,"r");
if(fp1 == NULL){
fprintf(stderr,"fopen file %s fail:%s\n",p->src_file,strerror(errno));
exit(EXIT_FAILURE);
}

fp2 = fopen(p->des_file,"a");
if(fp2 == NULL){
fprintf(stderr,"fopen file %s fail:%s\n",p->des_file,strerror(errno));
exit(EXIT_FAILURE);
}


fseek(fp1,p->position,SEEK_SET);
fseek(fp2,p->position,SEEK_SET);
printf("p->position=%d,p->len=%d\n",p->position,p->len);
read_len = p->len > 4096?4096:p->len;

while(1){
if(count >= p->len){
break; 
}
printf("read_len=%d\n",read_len);
n = fread(buf,sizeof(buf[0]),read_len,fp1);
if(n <= 0){
printf("fread over: %d\n",n);
break; 
}
printf("n=%d\n",n);
ret = fwrite(buf,sizeof(buf[0]),n,fp2);
if(ret <= 0){
printf("fwrite over\n");
break; 
}
count += n;
}
printf("write %d bytes to des file\n",count);


fclose(fp1);
fclose(fp2);
// pthread_mutex_unlock(&lock);
}


int main(int argc, const char *argv[])
{
int ret;
int len;
int position;
struct args args1,args2;
pthread_t tid1,tid2;


//pthread_mutex_init(&lock,NULL);


if(argc < 3){
fprintf(stderr,"Usage: %s <filename> <filename>\n",argv[0]);
exit(EXIT_FAILURE);
}


len = get_filelen(argv[1]);
position = len / 2;
init_args(&args1,argv[1],argv[2],0,position);
init_args(&args2,argv[1],argv[2],position,len-position);
fprintf(stdout,"src file length=%d\n",len);


ret = pthread_create(&tid1,NULL,copy_file,&args1);
if(ret != 0){
fprintf(stderr,"create pthread tid1 fail: %s\n",strerror(errno));
exit(EXIT_FAILURE);
}




ret = pthread_create(&tid2,NULL,copy_file,&args2);
if(ret != 0){
fprintf(stderr,"create pthread tid2 fail: %s\n",strerror(errno));
exit(EXIT_FAILURE);
}


pthread_join(tid1,NULL);
pthread_join(tid2,NULL);


}

秒客网

多进程和多线程文件拷贝

相关文章