多进程拷贝文件

                                                                        PS:多线程拷贝文件--->多线程拷贝文件-CSDN博客

要求：

 使用两个进程拷贝文件，父进程拷贝前一半，子进程拷贝后一半。

PS：光标问题:如果在fork前拷贝文件，父子进程共用光标，如果想父子进程不共用光标，父子进    程各自使用各自的fd即可。

本练习使用到两个函数

多进程fork函数

#include <sys/types.h>
#include <unistd.h>

pid_t fork(void);
功能：创建子进程
参数：
    @：无
返回值：成功：父进程收到子进程的pid,子进程收到0
     失败：子进程没有被创建，父进程收到-1，置位错误码

光标定位lseek函数

#include <sys/types.h>
#include <unistd.h>

off_t lseek(int fd, off_t offset, int whence);
功能：设置光标的位置
参数：
    @fd:文件描述符
 @offset:偏移量
        >0 向后偏移
        =0 不偏移
        <0 向前偏移
 @whence:从哪里开始偏移
        SEEK_SET:开头
        SEEK_CUR:当前位置
  SEEK_END:结尾
返回值：成功返回光标到文件开头的字节数，失败返回-1置位错误码 （PS：等价ftell fseek）

wait函数

#include <sys/wait.h>

pid_t wait(int *wstatus);
功能：阻塞等待回收子进程的资源（如果有多个子进程，谁先结束回收谁 PS:假如有三个子进程 想全部回收 调3次wait() ）
参数：
    @wstatus:获取子进程退出时候的状态值
返回值：成功返回回收掉的子进程的pid，失败返回-1，置位错误码
        
WIFEXITED(wstatus)：当进程正常退出（exit/_exit/return）它返回真
WEXITSTATUS(wstatus)：获取wstatus的bit8-bit15,代表子进程退出的状态
WIFSIGNALED(wstatus)：如果进程被信号终止返回值
WTERMSIG(wstatus)：获取的是让子进程退出时候的信号号，它是wstatus的bit0-bit6

pid_t waitpid(pid_t pid, int *wstatus, int options);
功能：回收子进程的资源
参数：
    @pid:子进程号
      < -1    首先回到pid取绝对值和绝对值同组的任意子进程的资源都可以被回收
       -1     等待回收任意子进程的资源
       0      等待回收组id和调用进程组id相同的任意子进程的资源
       > 0    指定回收pid子进程的资源
 @wstatus:子进程退出状态
 @options:回收资源的方式
        0       ：阻塞回收
        WNOHANG ：非阻塞回收子进程的资源
        （调用这个函数的时候子进程结束了，回收资源）
        （调用的时候子进程没有结束，这个函数立即返回，就不再回收资源了）
返回值：如果回收掉了子进程的资源返回子进程的pid
        如果是非阻塞的方式没有回收掉子进程的资源返回0
        如果是失败返回-1，置位错误码

wait(NULL) <===等价于===>waitpid(-1,NULL,0)

多进程同时拷贝文件：

#include <head.h>
int get_file_len(const char *src)
{
    int fd, len;
    if (-1 == (fd = open(src, O_RDONLY)))
    {
        perror("open src error");
        exit(-1);
    }
    len = lseek(fd, 0, SEEK_END);
    close(fd);
    return len;
}
int init_dest_file(const char *dest)
{
    int fd;
    if (-1 == (fd = open(dest, O_WRONLY | O_CREAT | O_TRUNC, 0666)))
    {
        perror("open dest error");
        exit(-1);
    }
    close(fd);
    return 0;
}
int copy_file(const char *src, const char *dest, int start, int len)
{
    char buff[16] = {0};
    int ret, count;
    int srcfd, destfd;
    if (-1 == (srcfd = open(src, O_RDONLY)))
    {
        perror("open src error");
        exit(-1);
    }
    if (-1 == (destfd = open(dest, O_WRONLY)))
    {
        perror("open dest error");
        exit(-1);
    }
    lseek(srcfd, start, SEEK_SET);
    lseek(destfd, start, SEEK_SET);
    while (1)
    {
        if (-1 == (ret = read(srcfd, buff, sizeof(buff))))
        {
            perror("read error");
            exit(-1);
        };
        if (len < sizeof(buff))
        {
            write(destfd, buff, len);
            break;
        }
        else
        {
            write(destfd, buff, ret);
        }
        len -= ret;
    }
    close(srcfd);
    close(destfd);
    return 0;
}

int main(int argc, const char *argv[])
{
    if (3 != argc)
    {
        printf("uasge error:%s srcfile destfile", argv[0]);
    }
    int len;
    len = get_file_len(argv[1]);
    init_dest_file(argv[2]);
    pid_t pid;
    pid = fork();
    if (-1 == pid)
    {
        perror("fork error");
        exit(-1);
    }
    else if (pid == 0)
    {
        // 子进程  拷贝后一半内容
        copy_file(argv[1], argv[2], len / 2, (len - (len / 2)));
    }
    else
    {
        // 父进程 拷贝前一半内容
        copy_file(argv[1], argv[2], 0, len / 2);
        wait(NULL); // 阻塞等待回收子进程
    }
    return 0;
}