1.基本

　　用线程池实现一个大文件夹的拷贝，大文件夹嵌套很多小文件；实现复制到指定文件夹的全部文件夹。

2.扩充功能

　　显示进度条；拷贝耗时统计；类似linux的tree，不能直接用system()与exec()等函数；根据文件类型拷贝；搜索文件；删除文件等。(暂时加了这么一些功能)

8月17日补：移动、复制到的目录已包含该文件则选择覆盖或者加命名。

　　先完成基本，逐步完成扩展再优化重构代码。

基本功能

　　基于linux，通过线程池实现的。核心就是线程池的三大基本功能--线程例程、添加线程、销毁线程池。由这三个为基础，对项目进行展开。基本功能，即通过递归读取目录，通过strucr dirent *p这个结构体来实现判断文件类型。如果是普通文件，直接在新目录用文件IO的读写实现拷贝功能(包括标准IO、系统IO，还有共享内存也可以实现)，拷贝那里用“添加线程”，保证可以多线程实现拷贝；如果是目录文件，就先创建文件夹--mkdir()，再sprintf拼接字符串以及函数的递归实现子级目录的拷贝。

->拷贝代码

void *myregcp(void *myarg)
{
struct copypath *mypath=(struct copypath *)myarg;

//系统IO的复制  
int fd1,fd2;  
fd1=open(mypath->oldpath,O\_RDONLY);  
fd2=open(mypath->newpath,O\_CREAT|O\_TRUNC|O\_RDWR,0777);  
if(fd1==-1)  
{  
    perror("打开1失败\\n");  
    return NULL;  
}  
if(fd2==-1)  
{  
    perror("打开2失败\\n");  
    return NULL;  
}  
char buf\[SIZE\];  
int nread,nwrite;  
while(1)  
{  
    bzero(buf,SIZE);  
    nread=read(fd1,buf,SIZE);  
    if(nread==0)  
        break;  
    cs=cs+nread;  
    write(fd2,buf,nread);  
}  
close(fd1);  
close(fd2);  
return NULL;  

}

->递归读取全部目录

int myreaddir(struct copypath *pp,struct threadpool *pool)
{
DIR *dirp=opendir(pp->oldpath);
if(dirp==NULL)
{
perror("失败:\n");
return -1;
}
struct dirent *p;
while((p=readdir(dirp))!=NULL)
{
if(p->d_type==DT_REG) //普通文件
{
struct copypath *mypath=malloc(sizeof(struct copypath));
sprintf(mypath->oldpath,"%s/%s",pp->oldpath,p->d_name);
sprintf(mypath->newpath,"%s/%s",pp->newpath,p->d_name);
add_task(myregcp,mypath,pool); //实现
}
if(p->d_type==DT_DIR) //文件夹
{
if(strcmp(p->d_name,".")!=0 && strcmp(p->d_name,"..")!=0)
{
struct copypath *mydirpath=malloc(sizeof(struct copypath));
sprintf(mydirpath->oldpath,"%s/%s",pp->oldpath,p->d_name);
sprintf(mydirpath->newpath,"%s/%s",pp->newpath,p->d_name);
mkdir(mydirpath->newpath,0777);
myreaddir(mydirpath,pool);
}
}
}
closedir(dirp);
return 1;
}

　　这样就大概完成基本功能，用多线程实现大文件夹的拷贝。

扩充功能

->进度条

　　定义两个全局变量，一个用于计算总字节数，另一个计算每次复制的字节数，再用一个显示函数实现进度条的显示。这里要注意缓冲区的问题，所以我用了"fflush(NULL)"这个函数，让它每打印一个'|'的时候，就刷新一次缓冲区。计算总的字节数直接递归全部目录，用"struct stat info"这个结构体里面的"info.st_size"累加，即可得到总的字节数；拷贝功能函数里面有个"cs"变量，就是存放拷贝字节数。显示进度条就用简单的判断，加相除实现。因为是显示20个|，所以我乘20。

　　num=(float)cs; //正在复制字节数
　　k=(num/s)*20;

->耗时

　　有三种思路，用clock()、time()、sleep(1)等都可以实现计时，直接在拷贝前和拷贝后加赋值，然后相减，即可。起初自己是用clock()这个函数，但是每次都是三秒。。。然后转到sleep()，让它自己while()累加实现。

->代码实现树

　　还是递归的思想，递归如果是普通文件就打印，是目录文件夹就字符串拼接再递归打印子文件夹下的子文件。

void dirtree(char dirpath[],int level)
{
int i;
char *dirname=NULL;
int dirlen;
DIR *dp=opendir(dirpath);
if(dp==NULL)
{
perror("失败:\n");
return;
}
struct dirent *ep;
while((ep=readdir(dp))!=NULL)
{
if(strncmp(ep->d_name, ".", 1) == 0)
continue;
for(i=0;id_name);
if(ep->d_type==DT_DIR)
{
//当前目录长度
dirlen=strlen(dirpath)+1;
//备份
dirname=(char *)malloc(dirlen);
memset(dirname,0,dirlen);
memcpy(dirname,dirpath,dirlen);

        strcat(dirpath,"/");  
        strcat(dirpath,ep->d\_name);  
        dirtree(dirpath,level+1);        //递归实现树效果  
        //恢复之前的目录名  
        memcpy(dirpath,dirname,dirlen);  
        free(dirname);  
        dirname = NULL;  
    }  
}  
closedir(dp);  

}

->按类型拷贝文件

　　也比较简单，另建一个递归读目录的函数，在普通文件加个if条件判断就可以。

　　if(strstr(p->d_name,ftype)!=NULL)

->搜索文件

　　类似于win的文件检索功能，在输入那个文件下面实现相似文件名的检索，并打印相关路径。也是递归读取目录，核心的改变代码也就一句。用"strstr()"寻找相应的子字符串，打印。

　　if(strstr(p->d_name,filename)!=NULL)

->删除文件夹

　　删除稍微要注意一下如果文件夹下面还有其他文件，就不能直接用"rmdir"删除文件夹。先用remove()删除文件，之后再删除子文件夹。也是用递归思想实现的。

　　现在还传不了，后期再传吧。

#include "myhead.h"
#define SIZE 1024*1024
long int s=0; //总字节数
long int cs=0; //计算每次复制的字节数
int tm=0; //计时--以秒为单位
int flag; //结束标志位
/***************************相关结构体的定义******************************/
struct copypath
{
char oldpath[256];
char newpath[256];
char target[50];
};
//创建任务链表结构体
struct tasklist
{
void *(*taskp)(void *);
void *taskarg;
struct tasklist *next;
};
//创建任务链表表头
struct tasklist *myhead;
//初始化任务链表
struct tasklist* task_init()
{
struct tasklist *mytask=malloc(sizeof(struct tasklist));
mytask->taskp=NULL;
mytask->taskarg=NULL;
mytask->next=NULL;
return mytask;
}
//创建线程池
struct threadpool
{
int threadnum;//统计当前线程数量
pthread_t *threadid;//存放当前线程的ID号
struct tasklist *taskhead;//保存任务链表的头结点
pthread_mutex_t threadmutex;//互斥锁
int tasknum;//统计任务链表中的数量
pthread_cond_t threadcond;//条件变量
bool threadflag;//用于判断线程池是否开启
};

//线程的多任务函数
void *routine(void *arg)
{
struct threadpool *pool=(struct threadpool *)arg;
//负责从任务链表的头结点的下一个位置取出任务然后处理
struct tasklist *p;
while(1)
{
//上锁
pthread_mutex_lock(&(pool->threadmutex));
//判断数量是否为0
while(pool->threadflag==true && pool->tasknum==0)
{
//printf("%ld线程阻塞--wait\n",pthread_self());
pthread_cond_wait(&(pool->threadcond),&(pool->threadmutex));
}
if(pool->threadflag==false&&pool->tasknum==0)
{
pthread_mutex_unlock(&(pool->threadmutex));
pthread_exit(NULL);
}
//取出节点处理
p=pool->taskhead->next;
pool->taskhead->next=p->next;
p->next=NULL;
//更新任务数量
pool->tasknum--;
//printf("%ld线程正在执行任务\n",pthread_self());
//解锁
pthread_mutex_unlock(&(pool->threadmutex));
(p->taskp)(p->taskarg);
free(p);
}
}
//初始化线程池结构体
struct threadpool *thread_init(int num)
{
struct threadpool *mythread=malloc(sizeof(struct threadpool));//申请堆空间
mythread->threadnum=num;
mythread->threadid=malloc(num*sizeof(pthread_t));
//初始化链表的表头
mythread->taskhead=myhead;
//锁初始化
pthread_mutex_init(&(mythread->threadmutex),NULL);
//条件变量初始化
pthread_cond_init(&(mythread->threadcond),NULL);
mythread->tasknum=0;
mythread->threadflag=true;
for(int i=0;ithreadid[i]),NULL,routine,mythread);
return mythread;
}
//添加任务函数
int add_task(void *(*p)(void *),void *newarg,struct threadpool *pool)
{
//找到尾部
struct tasklist *q=pool->taskhead;
while(q->next!=NULL)
q=q->next;
//准备新结点
struct tasklist *newnode=malloc(sizeof(struct tasklist));
newnode->taskp=p;
newnode->taskarg=newarg;
newnode->next=NULL;

//上锁  
pthread\_mutex\_lock(&(pool->threadmutex));  
//尾插  
q->next=newnode;  
//更新任务数量  
pool->tasknum++;  
pthread\_mutex\_unlock(&(pool->threadmutex));  
//唤醒条件  
pthread\_cond\_signal(&(pool->threadcond));  
return 0;  

}
/***************************************************************************/
// 功能函数
/***************************************************************************/
//主目录名
void *mycopyname(void *myarg)
{
struct copypath *mypath=(struct copypath *)myarg;
char fpath[15]; //求出主目录的名字
char temp[100];
strcpy(temp,mypath->oldpath);
char *p=strtok(temp,"/");
//获取文件名
while(p!=NULL)
{
bzero(fpath,15);
strcpy(fpath,p);
p=strtok(NULL,"/");
}
strcpy(((struct copypath *)myarg)->target,fpath);
}
//普通文件复制
void *myregcp(void *myarg)
{
struct copypath *mypath=(struct copypath *)myarg;

//系统IO的复制  
int fd1,fd2;  
fd1=open(mypath->oldpath,O\_RDONLY);  
fd2=open(mypath->newpath,O\_CREAT|O\_TRUNC|O\_RDWR,0777);  
if(fd1==-1)  
{  
    perror("打开1失败\\n");  
    return NULL;  
}  
if(fd2==-1)  
{  
    perror("打开2失败\\n");  
    return NULL;  
}  
char buf\[SIZE\];  
int nread,nwrite;  
while(1)  
{  
    bzero(buf,SIZE);  
    nread=read(fd1,buf,SIZE);  
    //cs=cs+nread;  
    if(nread==0)  
        break;  
    cs=cs+nread;  
    write(fd2,buf,nread);  
}  
close(fd1);  
close(fd2);  
return NULL;  

}
//遍历读目录
int myreaddir(struct copypath *pp,struct threadpool *pool)
{
DIR *dirp=opendir(pp->oldpath);
if(dirp==NULL)
{
perror("失败:\n");
return -1;
}
struct dirent *p;
while((p=readdir(dirp))!=NULL)
{
if(p->d_type==DT_REG) //普通文件
{
struct copypath *mypath=malloc(sizeof(struct copypath));
sprintf(mypath->oldpath,"%s/%s",pp->oldpath,p->d_name);
sprintf(mypath->newpath,"%s/%s",pp->newpath,p->d_name);
add_task(myregcp,mypath,pool); //实现
}
if(p->d_type==DT_DIR) //文件夹
{
if(strcmp(p->d_name,".")!=0 && strcmp(p->d_name,"..")!=0)
{
struct copypath *mydirpath=malloc(sizeof(struct copypath));
sprintf(mydirpath->oldpath,"%s/%s",pp->oldpath,p->d_name);
sprintf(mydirpath->newpath,"%s/%s",pp->newpath,p->d_name);
mkdir(mydirpath->newpath,0777);
myreaddir(mydirpath,pool);
}
}
}
closedir(dirp);
return 1;
}
//递归算字节数
int size_sum(struct copypath *pp)
{
DIR *dirp=opendir(pp->oldpath);
if(dirp==NULL)
{
perror("失败:\n");
return -1;
}
struct dirent *p;
struct stat info;
while((p=readdir(dirp))!=NULL)
{
if(p->d_type==DT_REG) //普通文件
{
struct copypath *mypath=malloc(sizeof(struct copypath));
sprintf(mypath->oldpath,"%s/%s",pp->oldpath,p->d_name);
//计算字节数
stat(mypath->oldpath,&info);
s=s+info.st_size;
}
if(p->d_type==DT_DIR) //文件夹
{
if(strcmp(p->d_name,".")!=0 && strcmp(p->d_name,"..")!=0)
{
struct copypath *mydirpath=malloc(sizeof(struct copypath));
sprintf(mydirpath->oldpath,"%s/%s",pp->oldpath,p->d_name);
size_sum(mydirpath);
}
}
}
closedir(dirp);
return 1;
}
//实现进度条
void *pro_bar(void *myarg)
{
int i,j=0;
float k,num;
printf("进度:");
while(1)
{
j=k;
num=(float)cs; //正在复制字节数
k=(num/s)*20; //
k=(int)k;
if(k-j>=1)
{
for(i=0;ioldpath);
if(dirp==NULL)
{
perror("失败:\n");
return -1;
}
struct dirent *p;
struct stat info;
while((p=readdir(dirp))!=NULL)
{
if(p->d_type==DT_REG) //普通文件
{
if(strstr(p->d_name,ftype)!=NULL) //文件类型
{
struct copypath *mypath=malloc(sizeof(struct copypath));
sprintf(mypath->oldpath,"%s/%s",pp->oldpath,p->d_name);
//计算字节数
stat(mypath->oldpath,&info);
s=s+info.st_size;
}
}
if(p->d_type==DT_DIR) //文件夹
{
if(strcmp(p->d_name,".")!=0 && strcmp(p->d_name,"..")!=0)
{
struct copypath *mydirpath=malloc(sizeof(struct copypath));
sprintf(mydirpath->oldpath,"%s/%s",pp->oldpath,p->d_name);
ftypesize_sum(mydirpath,ftype);
}
}
}
closedir(dirp);
return 1;
}
//递归读取文件类型的目录
int myftyper(struct copypath *pp,struct threadpool *pool,char *ftype)
{
DIR *dirp=opendir(pp->oldpath);
if(dirp==NULL)
{
perror("失败:\n");
return -1;
}
struct dirent *p;
while((p=readdir(dirp))!=NULL)
{
if(p->d_type==DT_REG) //普通文件
{
if(strstr(p->d_name,ftype)!=NULL)
{
struct copypath *mypath=malloc(sizeof(struct copypath));
sprintf(mypath->oldpath,"%s/%s",pp->oldpath,p->d_name);
sprintf(mypath->newpath,"%s/%s",pp->newpath,p->d_name);
add_task(myregcp,mypath,pool); //实现
}
}
if(p->d_type==DT_DIR) //文件夹
{
if(strcmp(p->d_name,".")!=0 && strcmp(p->d_name,"..")!=0)
{
struct copypath *mydirpath=malloc(sizeof(struct copypath));
sprintf(mydirpath->oldpath,"%s/%s",pp->oldpath,p->d_name);
sprintf(mydirpath->newpath,"%s/%s",pp->newpath,p->d_name);
mkdir(mydirpath->newpath,0777);
myftyper(mydirpath,pool,ftype);
}
}
}
closedir(dirp);
return 1;
}
//树实现
void dirtree(char dirpath[],int level)
{
int i;
char *dirname=NULL;
int dirlen;
DIR *dp=opendir(dirpath);
if(dp==NULL)
{
perror("失败:\n");
return;
}
struct dirent *ep;
while((ep=readdir(dp))!=NULL)
{
if(strncmp(ep->d_name, ".", 1) == 0)
continue;
for(i=0;id_name);
if(ep->d_type==DT_DIR)
{
//当前目录长度
dirlen=strlen(dirpath)+1;
//备份
dirname=(char *)malloc(dirlen);
memset(dirname,0,dirlen);
memcpy(dirname,dirpath,dirlen);

        strcat(dirpath,"/");  
        strcat(dirpath,ep->d\_name);  
        dirtree(dirpath,level+1);        //递归实现树效果  
        //恢复之前的目录名  
        memcpy(dirpath,dirname,dirlen);  
        free(dirname);  
        dirname = NULL;  
    }  
}  
closedir(dp);  

}

//递归查找相似文件-查找文件
int sc_file(struct copypath *pp,char *filename)
{
DIR *dirp=opendir(pp->oldpath);
if(dirp==NULL)
{
perror("失败:\n");
return -1;
}
struct dirent *p;
while((p=readdir(dirp))!=NULL)
{
if(p->d_type==DT_REG) //普通文件
{
if(strstr(p->d_name,filename)!=NULL) //文件类型
{
struct copypath *mypath=malloc(sizeof(struct copypath));
sprintf(mypath->oldpath,"%s/%s",pp->oldpath,p->d_name);
printf("已找到文件路径:%s\n",mypath->oldpath);
free(mypath);
}
}
if(p->d_type==DT_DIR) //文件夹
{
if(strcmp(p->d_name,".")!=0 && strcmp(p->d_name,"..")!=0)
{
if(strstr(p->d_name,filename)!=NULL) //文件类型
{
struct copypath *mypath1=malloc(sizeof(struct copypath));
sprintf(mypath1->oldpath,"%s/%s",pp->oldpath,p->d_name);
printf("已找到文件路径:%s\n",mypath1->oldpath);
free(mypath1);
}
struct copypath *mydirpath=malloc(sizeof(struct copypath));
sprintf(mydirpath->oldpath,"%s/%s",pp->oldpath,p->d_name);
sc_file(mydirpath,filename);
}
}
}
closedir(dirp);
return 1;
}
//删除--文件\文件夹
int alldet(struct copypath *pp)
{
DIR *dirp=opendir(pp->oldpath);
struct dirent *p;
while((p=readdir(dirp))!=NULL)
{
if(p->d_type==DT_REG) //普通文件
{
struct copypath *mypath=malloc(sizeof(struct copypath));
sprintf(mypath->oldpath,"%s/%s",pp->oldpath,p->d_name);
remove(mypath->oldpath);
}
if(p->d_type==DT_DIR) //文件夹
{
if(strcmp(p->d_name,".")!=0 && strcmp(p->d_name,"..")!=0)
{
struct copypath *mydirpath=malloc(sizeof(struct copypath));
sprintf(mydirpath->oldpath,"%s/%s",pp->oldpath,p->d_name);
alldet(mydirpath);
rmdir(mydirpath->oldpath);
}
}
}
closedir(dirp);
rmdir((pp->oldpath));
return 1;
}
/***************************************************************************/

/***************************************************************************/
// 简化主程序
/***************************************************************************/
int simcopy_all(struct threadpool *mypool) //简化主程序--复制全部
{
tm=s=cs=0;
struct copypath paths; //新旧路径结构体
printf("请输入源文件\n");
scanf("%s",paths.oldpath);
printf("请输入目标文件\n");
scanf("%s",paths.newpath);
mycopyname(&paths);
sprintf(paths.newpath,"%s/%s",paths.newpath,paths.target);
mkdir(paths.newpath,0777);
size_sum(&paths); //计算字节数
usleep(20);
printf("总字节数：%ld\n",s);
add_task(my_time,NULL,mypool);
add_task(pro_bar,NULL,mypool);
myreaddir(&paths,mypool);
}
void simcopy(struct threadpool *mypool) //简化主程序--按文件类型复制
{
tm=s=cs=0;
char ftype[6]; //文件类型变量
struct copypath paths;
printf("请输入源文件\n");
scanf("%s",paths.oldpath);
printf("请输入目标文件\n");
scanf("%s",paths.newpath);
mycopyname(&paths);
sprintf(paths.newpath,"%s/%s",paths.newpath,paths.target);
mkdir(paths.newpath,0777);
printf("请输入要复制的文件类型，如.txt等\n");
scanf("%s",ftype);
ftypesize_sum(&paths,ftype);
printf("总字节数：%ld\n",s);
usleep(20);
add_task(my_time,NULL,mypool);
add_task(pro_bar,NULL,mypool);
myftyper(&paths,mypool,ftype);
}
void simtree() //简化主程序--文件树
{
char direntName[256];
struct copypath paths;
printf("请输入源文件\n");
scanf("%s",paths.oldpath);
memset(direntName, 0, sizeof(direntName));
strcat(direntName, paths.oldpath);
printf("%s\n",paths.oldpath);
dirtree(direntName, 0);
}
void myscfile() //简化主程序--查找
{
char fname[256];
struct copypath paths;
printf("请输入查找文件夹名\n");
scanf("%s",paths.oldpath);
printf("请输入要查找的文件名\n");
scanf("%s",fname);
sc_file(&paths,fname);
usleep(10);
}
void mydel() //简化主程序--删除
{
tm=s=cs=0;
char delfile[100];
struct copypath paths;
printf("请输入要删除的文件夹\n");
scanf("%s",paths.oldpath);
size_sum(&paths); //计算字节数
printf("size is: %ld\n",s);
alldet(&paths);
usleep(10);
}
void endshow() //简化主程序--结束
{
printf("请输入 \n");
printf(" 1--继续 \n");
printf(" 2--退出 \n");
scanf("%d",&flag);
}
/***************************************************************************/
//销毁线程池
int pool_destroy(struct threadpool *pool)
{
int i;
//改变标志位，让线程退出死循环
pool->threadflag=false;
//唤醒所有线程
pthread_cond_broadcast(&(pool->threadcond));
//回收所有线程
for(i=0;ithreadnum;i++)
{
pthread_join(pool->threadid[i],NULL);
//printf("%ld线程已被回收\n",pool->threadid[i]);
}
return 0;
}

int main()
{
struct copypath paths;
while(1)
{
flag=0;
system("clear");
myhead=task_init(); //初始化任务链表的表头
struct threadpool *mypool=thread_init(10); //创建并初始化线程池
int ret=showdow();
switch(ret)
{
case 1: //拷贝全部
simcopy_all(mypool);
pool_destroy(mypool); //线程池的销毁
printf("拷贝花费:%d seconds\n",tm);
break;
case 2: //拷贝部分
simcopy(mypool);
pool_destroy(mypool);
printf("拷贝花费:%d seconds\n",tm);
break;
case 3: //显示文件树
simtree();
break;
case 4: //查找某个文件--显示相似的文件
myscfile();
break;
case 5: //删除某个文件夹
mydel();
printf("delete done\n");
break;
default:
break;
}
endshow();
if(flag==1)
continue;
else if(flag==2)
break;
}
system("clear");
usleep(20);
return 0;
}

码源:

http://pan-yz.chaoxing.com/share/info/b54be58ad063e1e9

有什么建议，欢迎联系。邮箱:2460576606@qq.com