IO学习系列之使用多线程复制同一个文件内容

• 实例要求：
• 使用多线程复制同一个文件内容；
• 实例分析：
• 1.创建两个线程，即线程1、线程2，设置光标在指定文件中的偏移量，实现对同一个文件的复制。
• 2.比如：可以指定线程1复制文件内容的前一半，而线程2复制文件内容的后一半。
• 3.根据时间片轮询法则，最终线程1和线程2可以把同一个文件复制成功。
• 相关的线程库接口函数如下：
• pthread_create函数：

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,

                   void *(*start_routine) (void *), void *arg);
/*
功能：

		创建一个线程

参数：

    	thread: 创建的线程的线程号

    	attr: 线程属性 传 NULL 表示使用默认属性

    	start_routine: 线程处理函数--线程体

    	arg: 线程处理函数的参数

返回值：

    	成功  	0

    	失败  	错误码 
*/

• pthread_self函数：

#include <pthread.h>

pthread_t pthread_self(void);
/*

功能：

		返回当前线程的线程号
	
参数：
		无

返回值：

		总是成功 当前线程的线程号
*/

• pthread_exit函数：

#include <pthread.h>

void pthread_exit(void *retval);
/*
功能：

		退出线程

    	线程中调用 exit 会导致整个进程退出

    	所以 如果只想退出线程 需要使用 pthread_exit
参数：

		退出线程时的返回值 给 pthread_join 使用的

返回值：

		无
*/

• pthread_join函数：

#include <pthread.h>

int pthread_join(pthread_t thread, void **retval);
/*
功能：

		阻塞等待一个结合态的线程退出，回收资源

		如果没有线程退出，该函数已知阻塞

参数：

		thread：线程的id

		retval：接受pthread_exit返回的值的 如果不关心 传NULL即可

返回值：

    	成功  0

    	失败  错误码
*/

• pthread_detach函数：

#include <pthread.h>

int pthread_detach(pthread_t thread);
/*
功能：	

		标记一个线程为分离态

参数：	

		thread：线程的id

返回值：

		成功 	 0

		失败  	错误码
*/

• pthread_cancel函数：

#include <pthread.h>

int pthread_cancel(pthread_t thread);
/*
功能：

	给线程发一个取消信号

	线程能否被取消以及能否被立即取消取决于线程的 state 和 type

	也就是与下面两个函数有关

	7.pthread_setcancelstate函数

	8.pthread_setcanceltype函数

参数：
	thread：线程的id

*/
//返回值：
int pthread_setcancelstate(int state, int *oldstate);

//state:
	PTHREAD_CANCEL_ENABLE  	//可被取消  --默认状态


	PTHREAD_CANCEL_DISABLE  //不可被取消


int pthread_setcanceltype(int type, int *oldtype);

//type:
	PTHREAD_CANCEL_ASYNCHRONOUS  	//可以被立即取消


	PTHREAD_CANCEL_DEFERRED   	//不可以被立即取消--默认状态

• 示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdbool.h>
#include <pthread.h>

typedef struct INFO
{
    const char *src_file;
    const char *dest_file;
    int offset;
    int size;

}info_t;

//获取源文件的大小（字节）
//创建目标文件

int get_src_file_size_and_create_dest_file(const char *src_file,const char *dest_file);

//复制源文件内容到目标文件内容中

void *cp_src_file_to_dest_file(void *arg);

int main(int argc, char const *argv[])
{
    if(3 != argc)
    {
        printf("Usage : %s src_file dest_file\n",argv[0]);
        return -1;
    }

    int size = 0;

    size = get_src_file_size_and_create_dest_file(argv[1],argv[2]);

    //线程1复制文件内容的前一半
    //线程2复制文件内容的后一半
    info_t arg[2] = {

        {argv[1],argv[2],0,size/2},

        {argv[1],argv[2],size/2,size - size/2}

    };

    pthread_t thread_1_id = 0;

    pthread_t thread_2_id = 0;

    int ret = 0;

    //创建线程1
    if(0 != (ret = pthread_create(&thread_1_id,NULL,cp_src_file_to_dest_file,&arg[0])))
    {
        printf("pthread_create error : errno = [%d] errstr = [%s]\n",ret,strerror(ret));
        exit(EXIT_FAILURE);
    }
    //创建线程2
    if(0 != (ret = pthread_create(&thread_2_id,NULL,cp_src_file_to_dest_file,&arg[1])))
    {
        printf("pthread_create error : errno = [%d] errstr = [%s]\n",ret,strerror(ret));
        exit(EXIT_FAILURE);
    }

    //线程1阻塞等待一个结合态的线程退出并回收资源
    pthread_join(thread_1_id,NULL);

    //线程2阻塞等待一个结合态的线程退出并回收资源
    pthread_join(thread_2_id,NULL);
    return 0;
}

int get_src_file_size_and_create_dest_file(const char *src_file,const char *dest_file)
{
    //获取源文件的大小（字节）
    int src_fd = open(src_file,O_RDONLY);

    if(-1 == src_fd)
    {
        perror("open error");
        return -1;
    }

    int size = lseek(src_fd,0,SEEK_END);

    close(src_fd);

    //创建目标文件

    int dest_fd = open(dest_file,O_WRONLY | O_CREAT | O_TRUNC,0666);

    if(-1 == dest_fd)
    {
        perror("open error");
        return -1;
    }

    close(dest_fd);

    return size;
}

void *cp_src_file_to_dest_file(void *arg)
{
    //参数强制类型转换
    info_t info = *(info_t *)arg;

    int src_fd = 0;

    int dest_fd = 0;

    //打开源文件
    if(-1 == (src_fd = open(info.src_file,O_RDONLY)))
    {
        perror("open error");
        pthread_exit(NULL);
    }
    //打开目标文件
    if(-1 == (dest_fd = open(info.dest_file,O_WRONLY)))
    {
        perror("open error");
        pthread_exit(NULL);
    }

    //定位光标
    lseek(src_fd,info.offset,SEEK_SET);

    lseek(dest_fd,info.offset,SEEK_SET);

    int ret = 0;
    int num = 0;
    char buf[64] = {0};

    while (true)
    {
        ret = read(src_fd,buf,sizeof(buf));

        if(0 == ret)
        {
            break;
        }

        num += ret;

        if(num > info.size)
        {
            write(dest_fd,buf,info.size - (num - ret));
            break;
        }

        write(dest_fd,buf,ret);
       
    }
    //关闭文件
    close(src_fd);

    close(dest_fd);

}

• 运行结果：

linux@ubuntu:~$ gcc th2.c -lpthread
linux@ubuntu:~$ ./a.out k1.c k2.c
linux@ubuntu:~$ diff k1.c k2.c 
linux@ubuntu:~$ 

• 本示例代码，仅供参考