大文件处理：分片读写、进度回调、断点续传

说实话，大文件处理这个话题，我当年刚入行时踩过不少坑。那时候接手一个项目，要处理几个GB的日志文件，我直接用fread一把梭——结果程序跑了半小时，内存爆了，用户直接骂娘。嗯，从那以后我就明白了一个道理：大文件不能当小文件玩。

今天咱们就聊聊大文件处理的三个核心招式：分片读写、进度回调、断点续传。这三板斧用好了，几百GB的文件也能稳稳拿下。

为什么不能一次性读写？

你想想看，一个4GB的文件，你一次性读到内存里——先不说内存够不够，就算够，这期间程序卡死、断电、用户点取消，怎么办？全白干了。

我个人的习惯是：永远假设内存是稀缺资源。哪怕机器有64GB内存，我也只按块处理。这不是保守，这是工程素养。

核心原则：大文件处理 = 分而治之 + 状态记录 + 容错恢复

分片读写：把大象装进冰箱

分片读写的思路很简单：把一个大文件切成若干小块，每次只处理一小块。就像吃西瓜，你不可能一口吞下整个西瓜，得切成片慢慢吃。

来看一个我常用的分片读取模板：

#include <stdio.h>
#include <stdlib.h>

#define CHUNK_SIZE (1024 * 1024)  // 1MB 一片

int process_large_file(const char *path) {
    FILE *fp = fopen(path, "rb");
    if (!fp) {
        perror("打开文件失败");
        return -1;
    }

    // 获取文件总大小
    fseek(fp, 0, SEEK_END);
    long total_size = ftell(fp);
    rewind(fp);

    char *buffer = (char*)malloc(CHUNK_SIZE);
    if (!buffer) {
        fclose(fp);
        return -1;
    }

    long bytes_read = 0;
    size_t nread;
    
    while ((nread = fread(buffer, 1, CHUNK_SIZE, fp)) > 0) {
        // 处理这一片数据
        process_chunk(buffer, nread);
        
        bytes_read += nread;
        // 这里可以更新进度
        printf("已处理: %.2f%%\n", 
               (double)bytes_read / total_size * 100);
    }

    free(buffer);
    fclose(fp);
    return 0;
}

这里有个细节要注意：CHUNK_SIZE选多大？我一般推荐1MB到16MB之间。太小了IO次数太多，太大了又浪费内存。我在项目中测试过，4MB左右在机械硬盘上表现最好，SSD可以适当大一些。

我的经验：分片大小最好对齐到文件系统的块大小（通常是4KB），这样读写效率最高。另外，如果处理的是网络文件，分片可以小一点，避免单次传输超时。

进度回调：让用户知道你没死机

用户最怕什么？程序没反应。你处理一个10GB的文件，界面卡住不动，用户第一反应就是「这程序死了」，然后直接关掉。

所以进度回调不是锦上添花，是刚需。我习惯用回调函数的方式来实现：

// 进度回调函数类型
typedef void (*progress_callback)(long current, long total);

// 带进度回调的分片处理
int process_with_progress(const char *path, 
                          progress_callback cb) {
    FILE *fp = fopen(path, "rb");
    if (!fp) return -1;

    fseek(fp, 0, SEEK_END);
    long total = ftell(fp);
    rewind(fp);

    char buf[CHUNK_SIZE];
    long processed = 0;
    size_t n;

    while ((n = fread(buf, 1, CHUNK_SIZE, fp)) > 0) {
        process_chunk(buf, n);
        processed += n;
        
        // 调用回调，通知进度
        if (cb) {
            cb(processed, total);
        }
    }

    fclose(fp);
    return 0;
}

// 使用示例
void my_progress(long current, long total) {
    int percent = (int)(current * 100 / total);
    printf("\r进度: %d%%", percent);
    fflush(stdout);
}

int main() {
    process_with_progress("bigfile.dat", my_progress);
    printf("\n完成！\n");
    return 0;
}

为什么用回调而不是直接打印？说白了，解耦。处理文件的逻辑不应该关心进度怎么展示——你可以打印、可以更新UI、可以发消息给其他线程。回调函数把「做什么」和「怎么展示」分开了。

注意：回调函数里不要做耗时操作！我曾经见过有人在回调里写日志文件，结果进度回调本身成了性能瓶颈。回调应该轻量、快速，只做状态更新。

断点续传：从哪跌倒从哪爬起来

这是大文件处理里最实用的功能。想象一下：你下载一个50GB的游戏，下了49GB时网络断了——如果没有断点续传，你得从头再来。这谁受得了？

断点续传的核心就两件事：记录进度和恢复进度。

我一般用一个状态文件来记录：

typedef struct {
    char filename[256];   // 原文件名
    long total_size;      // 文件总大小
    long processed_size;  // 已处理大小
    time_t timestamp;     // 时间戳
} TransferState;

// 保存状态
int save_state(const char *state_file, TransferState *state) {
    FILE *fp = fopen(state_file, "wb");
    if (!fp) return -1;
    
    size_t written = fwrite(state, sizeof(TransferState), 1, fp);
    fclose(fp);
    
    return (written == 1) ? 0 : -1;
}

// 加载状态
int load_state(const char *state_file, TransferState *state) {
    FILE *fp = fopen(state_file, "rb");
    if (!fp) return -1;
    
    size_t read = fread(state, sizeof(TransferState), 1, fp);
    fclose(fp);
    
    return (read == 1) ? 0 : -1;
}

// 断点续传主函数
int resume_transfer(const char *src, const char *dst) {
    TransferState state;
    char state_file[300];
    snprintf(state_file, sizeof(state_file), "%s.state", dst);
    
    // 尝试加载状态
    long offset = 0;
    if (load_state(state_file, &state) == 0) {
        // 检查文件是否匹配
        if (strcmp(state.filename, src) == 0) {
            offset = state.processed_size;
            printf("发现断点，从 %ld 字节处续传\n", offset);
        }
    }
    
    // 打开源文件和目标文件
    FILE *fsrc = fopen(src, "rb");
    FILE *fdst = fopen(dst, "ab");  // 追加模式！
    if (!fsrc || !fdst) {
        if (fsrc) fclose(fsrc);
        if (fdst) fclose(fdst);
        return -1;
    }
    
    // 跳过已处理的部分
    if (offset > 0) {
        fseek(fsrc, offset, SEEK_SET);
    }
    
    // 获取总大小
    fseek(fsrc, 0, SEEK_END);
    long total = ftell(fsrc);
    fseek(fsrc, offset, SEEK_SET);
    
    // 分片处理
    char buf[CHUNK_SIZE];
    long processed = offset;
    size_t n;
    
    while ((n = fread(buf, 1, CHUNK_SIZE, fsrc)) > 0) {
        fwrite(buf, 1, n, fdst);
        processed += n;
        
        // 每处理一片就保存状态
        state.processed_size = processed;
        save_state(state_file, &state);
        
        // 进度显示
        printf("\r进度: %.2f%%", 
               (double)processed / total * 100);
        fflush(stdout);
    }
    
    // 处理完成，删除状态文件
    remove(state_file);
    
    fclose(fsrc);
    fclose(fdst);
    printf("\n传输完成！\n");
    return 0;
}

这段代码里有个关键点：每处理一片就保存一次状态。为什么？因为程序可能在任何时刻崩溃。如果你每100MB才保存一次，那崩溃时最多丢失100MB的进度。这个频率你可以自己调，我一般设成每处理1%或每处理10MB保存一次，取较小值。

断点续传的三大要素：
  1. 唯一标识：能确认「这个状态文件对应的是哪个文件」——我用文件名+时间戳
  2. 精确位置：记录已处理的字节偏移量
  3. 原子保存：状态写入要保证完整性，最好先写临时文件再重命名

知识体系总览

下面这张图把大文件处理的三个核心概念串起来了，你可以看到它们之间的关系：

大文件处理核心架构 大文件处理 分片读写 进度回调 断点续传 关键点 • 固定大小分片（1MB~16MB） • 对齐文件系统块大小 • 循环读取直到EOF • 内存占用可控 关键点 • 回调函数解耦 • 轻量快速，不做耗时操作 • 支持多种展示方式 • 实时反馈用户 关键点 • 状态文件记录进度 • 唯一标识匹配文件 • 频繁保存状态 • 追加模式恢复写入

避坑指南

做这么多年项目，我在大文件处理上栽过的跟头不少，挑几个典型的说说：

  • 我曾经用fseek定位到文件末尾后忘了rewind——结果读出来的全是0。后来我养成了习惯：每次fseek后都检查返回值，并且明确记录当前偏移量。
  • 状态文件写了一半程序崩溃了——恢复时读到损坏的状态，直接乱跳。解决方案：先写临时文件，写完后rename覆盖原文件，保证原子性。
  • 分片大小设成1字节——没错，我真见过有人这么干。结果一个1GB的文件产生了10亿次IO调用，性能惨不忍睹。分片大小要权衡，不是越小越好。
我的建议：如果你要处理超大文件（比如100GB以上），可以考虑用内存映射文件（mmap）。它把文件映射到虚拟地址空间，由操作系统帮你管理分页，代码写起来更简洁。不过要注意32位系统的地址空间限制。

好了，大文件处理的三个核心招式就聊到这儿。分片读写是基础，进度回调是用户体验，断点续传是工程保障。这三者配合使用，基本能应对绝大多数大文件场景。下次你遇到几百GB的文件，心里应该有底了吧？

公众号:蓝海资料掘金营，微信deep3321

← 上一章 📖 返回目录 下一章 →