使用线程完成图片拷贝，找出错误，修改父子进程拷贝图片文件

最新推荐文章于 2024-09-14 22:17:13 发布
最新推荐文章于 2024-09-14 22:17:13 发布
阅读量346 收藏 2
点赞数 11
文章标签： jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52417518/article/details/139638817
版权

（一）使用线程完成图片拷贝

        用线程完成图片拷贝，要求一个线程拷贝一半，另一个线程拷贝另一半。

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

void* write_tailhalf(void* buf){
    sleep(10);   //防止主线程还没有写完，分支进程就写数据了
    printf("后一半开始写了\n");
    int fd1 = **((int**)buf+0);
    int fd2 = **((int**)buf+1);
    int size = **((int**)buf+2);
    //写入后一半数据
    char ch = '\0';
    for(int i = 0; i < size - size/2; i++){
        if(-1 == read(fd1, &ch, sizeof(ch))){
            perror("read");
            return NULL;
        }

        if(-1 == write(fd2, &ch, sizeof(ch))){
            perror("write");
            return NULL;
        }
        memset(&ch, 0, sizeof(ch));
    }
    fprintf(stderr, "后一半写完\n");
    //结束分支线程，解除主线程阻塞
    pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
    if(argc < 3){
        printf("请输入要复制的文件名字和复制后的文件名字\n");
        return -1;
    }
    //以读的方式打开argv[1]文件
    int fd1 = open(argv[1], O_RDONLY);
    if(-1 == fd1){
        perror("open");
        return -1;
    }

    //以写的方式打开argv[2]文件
    int fd2 = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0777);
    if(-1 == fd2){
        perror("open");
        return -1;
    }

    //获取文件大小
    struct stat state;
    if(-1 == stat(argv[1], &state)){
        perror("state");
        return -1;
    }
    int size = state.st_size;

    //创建新线程
    pthread_t tid;
    int *p[3];
    *(p+0) = &fd1;
    *(p+1) = &fd2;
    *(p+2) = &size;
    //传递指针数组
    if(pthread_create(&tid, NULL, write_tailhalf, (void*)p) != 0){
        fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);
        return -1;
    }

    char buf = '\0';
    //复制前一半数据
    for(int i = 0; i < size / 2; i++){
        if(-1 == read(fd1, &buf, sizeof(buf))){
            perror("read");
            return -1;
        }
                                                                          
        if(-1 == write(fd2, &buf, sizeof(buf))){
            perror("write");
        }
        memset(&buf, 0, sizeof(buf));
    }

    fprintf(stdout, "前一半写完\n");
    //阻塞主线程，等待后一半写完
    pthread_join(tid, NULL);
    return 0;
}

（二）分析程序出错原因

出错：运行过程中，线程A循环打印全局变量buf字符串，并不是按照只有结果1234567或者7654321打印的.

个人思考：Linux的进程调度机制为:时间片轮询机制。即GPU以ms级别的速度在进程中来回切换。进程是资源分配的最小单位。

而同一个进程下的线程。共享该进程下的所有资源。那么我全局变量buf也是被线程A和线程B共享的，我在线程A中打印buf，在进程B中翻转buf，同一进程下的线程执行顺序可能不相同。

假如进程的时间片为10ms,其中线程A占2ms,线程B站3ms，主线程占3ms，当CPU执行线程B即翻转字符串，立马切换到了线程A即打印字符串，此时字符串自由部分发生交换，所以打印的结果错误·。

 #include <stdio.h>                                                            
 #include <string.h>
 #include <pthread.h>
 
 char buf[]  = "1234567";  //定义一个全局变量
 
 void swap(char* ch1, char* ch2){
     char tmp = *ch1;
     *ch1 = *ch2;
     *ch2 = tmp;
 }
 
 void* print_buf(void* argv){
     while(1){
         printf("%s\n", buf);
     }
 }
 
 void* buf_reverse(void* argv){
     int len = strlen(buf);
     int i;
     while(1){
         for(i = 0; i < len/2; i++){
             swap(&buf[i], &buf[len - i -1]);
         }
         i = 0;
     }
 }   
 
 int main(int argc, const char *argv[])
 {
     pthread_t tida;
     pthread_t tidb;
     //创建A线程
     if(pthread_create(&tida, NULL, print_buf, NULL) < 0){
         fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);
         return -1;
     }   
     
     //创建B进程
     if(pthread_create(&tidb, NULL, buf_reverse, NULL) < 0){
         fprintf(stderr, "pthread_create failed __%d__\n", __LINE__);
     }   
     
     //主线程阻塞
     pthread_join(tida, NULL);
     printf("主线程退出\n");
     return 0;
 }

（三）父子进程拷贝图片修改

将父子进程拷贝图片的那题目进行修改：

父子进程的代码单独分离到其他的可执行二进制程序用，用exec函数族进行组合。

提示：学习使用sprintf函数 atoi函数。

sprintf：将数据格式化输出到字符串中。char str[32]; int a = 10; sprintf(str, "%d", a);

atio：将数字型字符串转换成整数 "10" ---> atoi ---> 整型10

1、方法1：当打开文件在fork之前

主代码

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


int main(int argc, const char *argv[])
{
    if(argc < 3){
        printf("请输入需要拷贝文件名和拷贝后的文件名\n");
        return -1;
    }
    //以读的方式打开argv[1]文件
    int fd1 = open(argv[1], O_RDONLY);
    if(-1 == fd1){
        perror("fd1");
        return -1;
    }

    //以写的方式打开argv[2]文件,如果文件不存在，则创建,如果存在，清空
    int fd2 = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0777);
    if(-1 == fd2){                                                                  
        perror("fd2");
        return -1;
    }

    //获取argv[1]文件的大小
    struct stat state;
    if(-1 == stat(argv[1], &state)){
        perror("stat");
        return -1;
    }

    pid_t pid = fork();   //创建一个子进程
    if(pid > 0){         //父进程
        //写前一半数据
        off_t head_half = state.st_size / 2;
        char buf;
        while(head_half--){
            if(-1 == read(fd1, &buf, sizeof(buf))){
                perror("read");
                return -1;
            }

            if(-1 == write(fd2, &buf, sizeof(buf))){
                perror("write");
                return -1;
            }

        }
    }else if(0 == pid){   //子进程
        sleep(10);
        //写入后一半数据
        //父进程和子进程共用同一个文件描述符表
        //所以不需要修改文件偏移量
        //设置文件偏移量
        char str_fd1[3] = {0};
        char str_fd2[3] = {0};
        char str_size[32] = {0};
        //将后一半文件大小、文件描述符转化为字符串，传参给单独分离的程序使用
        sprintf(str_size, "%ld", state.st_size - state.st_size/2);
        sprintf(str_fd1, "%d", fd1);
        sprintf(str_fd2, "%d", fd2);
        execl("./proj", "proj", str_size, str_fd1, str_fd2, NULL);
    }else{
        perror("fork");
        return -1;
    }

    close(fd1);
    close(fd2);
    return 0;
}

进程重生代码

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

int main(int argc, const char *argv[])
{

    //进行后一半的复制
    char buf = '\0';
    //将字符换转换为整型
    int size = atoi(argv[1]);
    int fd1 = atoi(argv[2]);
    int fd2 = atoi(argv[3]);
    for(int i = 0; i < size; i++){
        if(-1 == read(fd1, &buf, sizeof(buf))){
            perror("read");                           
            return -1;
        }

        if(-1 == write(fd2, &buf, sizeof(buf))){
            perror("write");
            return -1;
        }

        memset(&buf, 0, 1);
    }
    return 0;

}

2、方法二：当打开文件在fork之后

主代码

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


int main(int argc, const char *argv[])
{
    if(argc < 3){
        printf("请输入需要拷贝文件名和拷贝后的文件名\n");
        return -1;
    }
    //以读的方式打开argv[1]文件
    int fd1 = open(argv[1], O_RDONLY);
    if(-1 == fd1){
        perror("fd1");
        return -1;
    }

    //防止先前的数据造成干扰
    int fd_w = open(argv[2], O_WRONLY | O_CREAT | O_TRUNC, 0777);                              
    if(-1 == fd_w){
        perror("open");
        return -1;
    }
    close(fd_w);

    //获取argv[1]文件的大
    off_t size = lseek(fd1, 0, SEEK_END);
    //偏移回去
    lseek(fd1, 0, SEEK_SET);
    pid_t pid = fork();   //创建一个子进程
    if(pid > 0){         //父进程
        int fd2 = open(argv[2], O_WRONLY | O_CREAT, 0777);
        if(-1 == fd2){
            perror("open");
            return -1;
        }
        printf("fd2 = %d\n", fd2);
        printf("size = %ld\n", size);
        //写前一半数据
        off_t head_half = size / 2;
        char buf;
        for(int i = 0; i < head_half; i++){
            if(-1 == read(fd1, &buf, sizeof(buf))){
                perror("read");
                return -1;
            }

            if(-1 == write(fd2, &buf, sizeof(buf))){
                perror("write");
                return -1;
            }
            memset(&buf, 0, 1);
        }
        fprintf(stderr, "前一半拷贝成功\n");
        close(fd2);
    }else if(0 == pid){   //子进程
        sleep(10);
        char str_fd1[5] = {0};
        char str_size[32] = {0};
        //将文件描述符和后一半大小转换字符串，传给重生之后的程序
        sprintf(str_fd1, "%d", fd1);
        sprintf(str_size, "%ld", size - size/2);
        execl("./proj", "proj", str_fd1, str_size, argv[2], NULL);

    }else{
        perror("fork");
        return -1;
    }

    close(fd1);
    return 0;
}

进程重生代码

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

int main(int argc, const char *argv[])
{

    //进行后一半的复制
    char buf = '\0';
    //将字符换转换为整型
    int size = atoi(argv[2]);
    int fd1 = atoi(argv[1]);

    int fd2 = open(argv[3], O_WRONLY | O_CREAT);
    if(-1 == fd2){
        perror("open");
        return -1;
    }
    //做文件偏移
    lseek(fd1, size-1, SEEK_SET);
    lseek(fd2, size-1, SEEK_SET);
    for(int i = 0; i < size; i++){
        if(-1 == read(fd1, &buf, sizeof(buf))){
            perror("read");
            return -1;
        }

        if(-1 == write(fd2, &buf, sizeof(buf))){
            perror("write");
            return -1;
        }
                                                             
        memset(&buf, 0, 1);
    }

    close(fd2);
    return 0;

}

“favor
关注
Linux学习 IO进程与线程： day4
haogewudi666的博客
06-11 443
【复习】 库：可执行代码的二进制形式 静态库：编译时 动态库(共享库)：运行时 便于复用 进程： 和程序的区别： 三段：数据段、正文段、堆栈段 分类：交互进程、批处理、守护进程 状态：运行态R、等待态、暂停态T、死亡态x、僵尸态Z 命令：ps -aux/-ef、top、kill、bg\fg 函数：fork、wait/waitpid、exit/_exit、execvpe 守护进程：1.fork 2.setsid 3.chdir...
2024.6.12 1.将父子进程拷贝图片进行修改 2.分析错误3.用线程的方式拷贝图片
qq_70471712的博客
06-12 151
这可能是因为A线程和B线程共享附属进程的资源，B线程运行到中间时分配给他的资源结束，回到A线程打印。B线程循环倒置buf字符串，即buf中本来存储1234567，倒置后buf中存储7654321. B线程中不打印！可以看见打印出来的整个字符串也出现重复，这可能是因为A线程运行时，B线程没有运行，再一次证明了linux以时间片轮回方式运行。2.要求定义一个全局变量 char buf[] = "1234567"，创建两个线程，不考虑退出条件。3.用线程完成图片拷贝，要求一个线程拷贝一半，另一个线程拷贝另一半。
使用exec函数族，父子进程分别拷贝图片前后部分
qq_51852604的博客
06-12 547
被分离的A线程的资源将被自动回收，不需要使用pthread_join回收了;当tid线程被分离后，phtread_join tid线程不阻塞，线程A不会再输出线程B过程中未全部的完成的过程乱码。分析：经过测试，将子进程A使用pthread_detach函数加入到创建进程A的程序下时候可以避免乱码的输出，
使用父子进程完成两个文件的拷贝父进程拷贝前一半内容，子进程拷贝后一半内容子进程结束后退出，父进程回收子进程的资源
sjrhsk_hahaha的博客
07-31 343
不多说直接上代码
Process进程 ; Thread线程 （拷贝文件，带进度条的使用实例）
Fanbin168的专栏
12-23 3134
前台线程和后台线程 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Diagnostics; namespace 进程Process { /// /// Process类是一个非静态类。它里面包含静态成员和非静态成员。静态成
IO进程线程Day5 文件夹拷贝 从文件中读取数据到内存，从内存写入到文件 父子进程发送消息
04-04
今天我们将深入探讨“IO进程线程Day5”中的核心知识点，包括文件夹拷贝、从文件读取数据到内存以及内存到文件的写入，以及父子进程间的消息传递。 首先，让我们关注文件夹拷贝这一过程。文件夹拷贝不仅仅是简单的...
线程并发拷贝程序实验报告及实验结果
11-20
【线程并发拷贝程序实验】是针对多线程环境下数据拷贝的一种实现方式，它利用线程的并发性提高程序执行效率。在这个实验中，我们关注的重点是线程的并发操作、进程间的通信以及资源的同步管理。 1. **线程并发**：...
常见的 JVM 调优方法有哪些？
weixin_41879185的博客
09-11 475
XX:MaxTenuringThreshold=15：对象每Minor GC在Survivor区存活一次 age++，当到age = 15的时候，直接进入老年代。-XX:NewRatio=4：表示设置 年轻代（包括Eden和两个Survivor区）/老年代 的大小比值为1：4，这意味着年轻代占整个堆的1/5。常用的CMS收集器： 设置回收阈值，需要根据程序的运行过程中的gc log来观察是否会用频繁的full gc 与 CMS gc。-XX:PermSize=64M 指的是JVM初始非堆内存。
JVM字节码
Flying_Fish_roe的博客
09-11 999
JVM字节码是Java虚拟机运行的核心组成部分，它通过平台无关的设计，实现了Java程序的跨平台性和高效性。字节码的指令集基于栈操作模型，具备丰富的功能，能够支持Java语言中的各种高级操作。同时，通过JIT编译器的动态优化，Java程序能够在保持良好兼容性的同时，获得接近原生代码的执行效率。JVM字节码不仅仅是Java程序运行的基础，也是整个Java生态系统的核心。在未来，随着JVM的不断优化和发展，字节码在性能和功能上的表现也将继续提升，为开发者提供更加高效和灵活的开发体验。
JVM锁的优化与逃逸分析
weixin_41879185的博客
09-11 1060
将不存在并发的代码块上加的锁进行消除。
垃圾收集器与内存分配策略
weixin_41879185的博客
09-11 891
垃圾收集器与内存分配策略
【JVM】类加载过程|双亲委派模型
qq_73017178的博客
09-11 1060
本文主要介绍了JVM的类加载过程：加载->验证->准备->解析->初始化;还介绍了类加载过程中的双亲委派模型，介绍及优点，还有破坏
JVM基础概念
qq_63688997的博客
09-11 920
Java 可以跨平台的最主要原因是因为 JVM ，因为不同的平台，使⽤的 JVM 不⼀样。
JVM 体系与结构
niceffking的博客
09-10 1139
一次编译导出运行 JVM不只是虚拟机, 更是一个平台 虚拟机? Java虚拟机? JVM在计算机系统中所处的位置 JVM的体系结构 Java代码的执行流程 JVM生命周期
JVM 调优篇7 调优案例1-堆空间的优化解决
最新发布
健康平安的活着的专栏
09-14 380
Full GC执行时间不到1s，Full GC执行频率不算频繁，不低于10分钟1次(>=10min/次)；Minor GC执行时间不到50ms，Minor GC执行不频繁，约10秒一次；多数导致GC问题的Java应用，都不是因为我们参数设置错误，而是代码问题；在应用上线之前，先考虑将机器的JVM参数设置到最优（最适合）；多数的Java应用不需要在服务器上进行GC优化；GC优化是到最后不得已才采用的手段；将转移到老年代的对象数量降低到最小；
考研复习-英语二真题考试题集-带答案
09-14
英语二考研真题复习资料，带答案版
2024中美独角兽公司发展分析报告.pdf
09-14
全球各大洲独角兽企业分布、中美独角兽企业对比（数量、估值、新增及退榜情况、行业分布、所在城市）、
C++ 中的异步编程模型是什么
09-14
在C++中，异步编程模型是处理并发任务、提高程序性能和响应性的关键技术。以下是C++中实现异步编程的几种主要方式： 每种异步编程模型都有其适用场景和优缺点。选择合适的模型可以提高代码的可读性、可维护性和性能。随着C++标准的不断发展，异步编程模型也在不断进化，为开发者提供了更多的工具和选择。 在实际开发中，应根据具体需求选择合适的异步编程模型。例如，对于简单的异步任务，回调函数可能是最直接的选择；而对于需要结构化错误处理和结果获取的复杂异步任务，std::async和std::future可能更合适；在需要高效资源管理的场景下，线程池是一个不错的选择；而对于需要编写大量异步代码的现代应用程序，协程提供了一种更简洁、更直观的解决方案。 总之，C++中的异步编程模型是多核和高并发环境下提高程序性能的重要工具。通过合理使用这些模型，开发者可以构建出更高效、更可靠的软件系统。
Linux fork函数详解：进程克隆与父子进程示例
`fork()`函数是Linux和类Unix环境中进程管理的核心功能之一，它实现了进程的复制，常用于多线程编程、守护进程等场景。理解`fork()`的工作原理和行为至关重要，尤其是在编写需要处理并发操作的程序时。通过学习`fork...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值