C++多线程断点续传下载器：从HTTP Range到并发控制的工程实现

如果你正在准备 C++ 后端开发岗位的面试，尤其是字节跳动这类大厂，那么“设计一个支持多线程并发下载且能断点续传的文件下载器”这道题，几乎是一个必考题。它考察的远不止是你会不会用 std::thread 或者 std::async ，而是对你综合能力的全面检验：从网络编程、多线程并发控制、文件 I/O 操作，到异常处理、资源管理和工程化设计思维。

很多人一看到这个题目，第一反应是去网上找一段“多线程下载”的代码，然后背下来。但面试官真正想听的，是你如何 系统性地解决这个问题 。一个能跑通的 Demo 只是及格线，而一个考虑周全、鲁棒性强、易于扩展的设计方案，才是拿到高分的钥匙。这篇文章，我们就来彻底拆解这道经典面试题，不仅给你一个可运行的代码框架，更重要的是，带你理解背后的设计哲学和那些容易踩坑的细节。

1. 这道面试题究竟在考察什么？

面试官抛出这个问题，通常有四个核心考察点，层层递进：

1. 基础能力扎实度 ：你是否真正理解 HTTP 协议（特别是 Range 头部）、文件操作、线程创建与管理这些基础知识。
2. 并发编程功底 ：这是核心。你如何划分任务？如何同步多个线程对共享资源（如文件指针、进度信息）的访问？如何避免死锁和数据竞争？原子操作、互斥锁、条件变量这些工具你是否能运用自如？
3. 工程化与鲁棒性思维 ：你的设计能否应对网络波动、服务器限制、磁盘空间不足、程序意外崩溃等异常情况？断点续传的状态如何持久化？下载任务如何优雅暂停和恢复？
4. 系统设计能力 ：你的代码结构是否清晰？是否易于扩展（比如支持 FTP 协议、动态调整线程数）？模块之间的职责是否明确？

因此，我们的设计目标不仅仅是“下载一个文件”，而是构建一个 可靠、高效、可维护的下载管理器 。下面，我们就从零开始，一步步实现它。

2. 核心概念与设计原理

在动手写代码之前，我们必须明确几个关键概念和整体设计思路。

2.1 断点续传 (Resume)

断点续传的核心是 HTTP/1.1 协议中的 Range 请求头。服务器如果支持，会在响应头中返回 Accept-Ranges: bytes 。当我们需要从某个位置继续下载时，可以发送如 Range: bytes=1024- 的请求头，告诉服务器“请从第 1024 个字节开始发送数据”。

为了实现断点续传，我们的程序需要：

• 记录已下载的字节范围 ：通常用一个文件（如 .tmp 状态文件）或数据库来记录每个分片（或整个文件）的下载进度。
• 支持暂停与恢复 ：暂停时，安全地保存当前状态；恢复时，读取状态并重新发起带 Range 头的请求。

2.2 多线程并发下载

单线程下载大文件效率低下，尤其是当网络延迟较高时。多线程并发下载将一个文件分成多个逻辑块（分片），每个线程负责下载一个分片，最后将所有分片按顺序拼接成完整文件。

关键问题 ：

• 如何分片？ 通常根据文件总大小和线程数平均划分。需要先通过一个 HEAD 请求获取文件总大小 ( Content-Length )。
• 分片边界对齐？ 对于某些流式或编码内容，可能需要考虑边界，但普通二进制文件通常不需要。
• 如何写入文件？ 多个线程不能同时向文件的同一个位置写入。我们需要让每个线程写入文件 不同的、预先分配好的位置 。这通常通过 seek 到指定偏移量再写入来实现。

2.3 整体架构设计

我们将采用“管理器-工作者”模型：

• DownloadManager (管理器) ：单例或主类。负责整个下载任务的元信息管理（URL、文件路径、总大小、线程数）、分片策略、状态持久化、进度汇总以及工作者线程的创建与协调。
• DownloadTask (任务/分片) ：描述一个下载分片所需的所有信息：下载区间 ( start_byte , end_byte )、当前已下载字节数、状态（未开始、下载中、已完成、错误）。
• DownloadWorker (工作者线程) ：每个线程一个工作者。它获取一个 DownloadTask ，负责执行具体的 HTTP 请求（带 Range 头），将收到的数据写入文件指定位置，并实时更新该分片的进度。

它们之间的关系和数据流如下图所示（概念示意）：

[用户启动下载]
        |
        v
[DownloadManager]
        | 1. 解析URL，发送HEAD请求获取文件大小
        | 2. 加载历史状态（如有）
        | 3. 创建N个DownloadTask（分片）
        | 4. 启动N个DownloadWorker线程
        |
        |-----> [Worker-1] -> 下载 Task-1 -> 写入文件偏移1
        |-----> [Worker-2] -> 下载 Task-2 -> 写入文件偏移2
        |-----> [Worker-...]
        |-----> [Worker-N] -> 下载 Task-N -> 写入文件偏移N
        |
        | 5. 等待所有Worker结束，汇总状态
        | 6. 所有分片完成？ -> 清理临时状态，重命名文件
        v
[下载完成/失败]

3. 环境准备与第三方库选择

我们将使用 C++17 标准进行开发。为了简化 HTTP 网络请求部分（这不是考察核心），我们选择一个轻量级、易用的第三方库。这里我们使用 cpr ，它是一个 C++ 的 HTTP 请求库，语法类似 Python 的 requests，非常直观。当然，你也可以用 libcurl，但 cpr 的封装更友好。

环境准备步骤：

1. 安装依赖 ：我们需要 cpr 和它的依赖（如 libcurl）。

   • Ubuntu/Debian : sudo apt-get install libcurl4-openssl-dev
   • macOS (Homebrew) : brew install curl
   • Windows (vcpkg) : vcpkg install cpr

2. 项目配置 (CMakeLists.txt) ： 创建一个 CMakeLists.txt 文件来管理项目依赖。

cmake_minimum_required(VERSION 3.10)
project(MultiThreadDownloader)

set(CMAKE_CXX_STANDARD 17)

# 查找 cpr 库，假设你已通过 vcpkg 或系统包管理器安装
find_package(cpr REQUIRED)

add_executable(downloader main.cpp download_manager.cpp download_worker.cpp)
target_link_libraries(downloader PRIVATE cpr::cpr)

3. 代码文件结构 ：

downloader/
├── CMakeLists.txt
├── main.cpp                 # 程序入口
├── download_manager.h/.cpp  # 下载管理器类
├── download_task.h          # 下载任务（分片）数据结构
├── download_worker.h/.cpp   # 工作者线程类
└── utils.h/.cpp             # 工具函数（如文件操作、字符串处理）

4. 核心类与数据结构实现

4.1 下载任务 (DownloadTask)

这是一个简单的 POD (Plain Old Data) 结构体，用于描述一个分片。

// download_task.h
#ifndef DOWNLOAD_TASK_H
#define DOWNLOAD_TASK_H

#include <string>
#include <atomic>

// 分片下载状态
enum class TaskStatus {
    PENDING,    // 等待下载
    DOWNLOADING, // 下载中
    COMPLETED,  // 已完成
    FAILED      // 失败
};

struct DownloadTask {
    int task_id;           // 分片ID
    std::string url;       // 下载地址
    long long start_byte;  // 起始字节
    long long end_byte;    // 结束字节（包含）
    long long total_size;  // 分片总大小 (end_byte - start_byte + 1)
    std::atomic<long long> downloaded; // 已下载字节数（原子操作，线程安全）
    TaskStatus status;     // 当前状态

    // 计算进度百分比
    double progress() const {
        if (total_size == 0) return 0.0;
        return (static_cast<double>(downloaded) / total_size) * 100.0;
    }

    // 判断是否已完成
    bool is_finished() const {
        return status == TaskStatus::COMPLETED || downloaded >= total_size;
    }
};

#endif // DOWNLOAD_TASK_H

关键点 ： downloaded 使用 std::atomic<long long> ，确保多个线程（如工作者线程更新进度、管理器线程读取总进度）同时访问时是线程安全的。

4.2 下载管理器 (DownloadManager)

这是整个系统的中枢，职责最重。

// download_manager.h
#ifndef DOWNLOAD_MANAGER_H
#define DOWNLOAD_MANAGER_H

#include <string>
#include <vector>
#include <memory>
#include <mutex>
#include <atomic>
#include "download_task.h"

class DownloadWorker; // 前向声明

class DownloadManager {
public:
    DownloadManager(const std::string& url, const std::string& output_path, int num_threads = 4);
    ~DownloadManager();

    bool start();       // 开始/恢复下载
    bool pause();       // 暂停下载
    bool stop();        // 停止下载（不可恢复）
    double get_overall_progress() const; // 获取总进度

private:
    bool fetch_file_info(); // 获取文件信息（大小，是否支持断点）
    void create_download_tasks(); // 创建分片任务
    void load_state();  // 从状态文件加载进度
    void save_state();  // 保存进度到状态文件
    void cleanup();     // 下载完成或停止后清理

    std::string m_url;
    std::string m_output_path;
    std::string m_temp_file_path; // 临时文件路径
    std::string m_state_file_path; // 状态文件路径

    long long m_file_size;
    bool m_support_resume;
    int m_num_threads;

    std::vector<DownloadTask> m_tasks;
    std::vector<std::unique_ptr<DownloadWorker>> m_workers;

    std::atomic<bool> m_is_paused;
    std::atomic<bool> m_is_stopped;
    mutable std::mutex m_tasks_mutex; // 保护 m_tasks 的并发访问（例如更新状态）

    // 工作线程函数
    friend class DownloadWorker;
    void worker_thread_func(int task_id);
};

#endif // DOWNLOAD_MANAGER_H

对应的 .cpp 文件会实现这些方法，特别是 start() 和 fetch_file_info() 。

// download_manager.cpp (部分关键实现)
#include "download_manager.h"
#include "download_worker.h"
#include <fstream>
#include <iostream>
#include <cpr/cpr.h> // 引入 cpr 库

DownloadManager::DownloadManager(const std::string& url, const std::string& output_path, int num_threads)
    : m_url(url), m_output_path(output_path), m_num_threads(num_threads),
      m_file_size(0), m_support_resume(false),
      m_is_paused(false), m_is_stopped(false) {
    // 构建临时文件和状态文件路径
    m_temp_file_path = output_path + ".tmp";
    m_state_file_path = output_path + ".state";
}

bool DownloadManager::fetch_file_info() {
    try {
        // 发送 HEAD 请求获取文件信息
        cpr::Response response = cpr::Head(cpr::Url{m_url});
        if (response.status_code != 200) {
            std::cerr << "Failed to get file info. HTTP Code: " << response.status_code << std::endl;
            return false;
        }

        auto it = response.header.find("Content-Length");
        if (it != response.header.end()) {
            m_file_size = std::stoll(it->second);
        } else {
            std::cerr << "Cannot determine file size (no Content-Length header)." << std::endl;
            return false;
        }

        // 检查服务器是否支持 Range 请求（断点续传）
        it = response.header.find("Accept-Ranges");
        if (it != response.header.end() && it->second == "bytes") {
            m_support_resume = true;
            std::cout << "Server supports resume (Range requests)." << std::endl;
        } else {
            m_support_resume = false;
            std::cout << "Warning: Server may not support resume. Fallback to single thread." << std::endl;
            m_num_threads = 1; // 不支持断点则退化为单线程
        }
        return true;
    } catch (const std::exception& e) {
        std::cerr << "Exception in fetch_file_info: " << e.what() << std::endl;
        return false;
    }
}

void DownloadManager::create_download_tasks() {
    m_tasks.clear();
    if (m_file_size <= 0) return;

    long long chunk_size = m_file_size / m_num_threads;
    long long remainder = m_file_size % m_num_threads;
    long long start = 0;

    for (int i = 0; i < m_num_threads; ++i) {
        DownloadTask task;
        task.task_id = i;
        task.url = m_url;
        task.start_byte = start;
        // 最后一个线程处理剩余字节
        task.end_byte = (i == m_num_threads - 1) ? (start + chunk_size + remainder - 1) : (start + chunk_size - 1);
        task.total_size = task.end_byte - task.start_byte + 1;
        task.downloaded = 0;
        task.status = TaskStatus::PENDING;

        m_tasks.push_back(task);
        start += chunk_size;
    }
}

bool DownloadManager::start() {
    if (m_is_stopped) {
        std::cerr << "Download has been stopped, cannot restart." << std::endl;
        return false;
    }

    // 1. 获取文件信息
    if (!fetch_file_info()) {
        return false;
    }

    // 2. 加载之前保存的状态（实现断点续传的关键）
    load_state();

    // 3. 如果从未创建过任务，则创建
    if (m_tasks.empty()) {
        create_download_tasks();
    }

    // 4. 打开或创建临时文件
    std::ofstream temp_file(m_temp_file_path, std::ios::binary | std::ios::app);
    if (!temp_file) {
        std::cerr << "Cannot open temp file: " << m_temp_file_path << std::endl;
        return false;
    }
    // 确保文件大小足够，避免后续 seek 出错
    temp_file.seekp(m_file_size - 1);
    temp_file.write("", 1);
    temp_file.close();

    // 5. 创建并启动工作线程
    m_is_paused = false;
    m_workers.clear();
    for (int i = 0; i < m_num_threads; ++i) {
        // 只启动未完成的任务
        if (m_tasks[i].status != TaskStatus::COMPLETED) {
            m_workers.emplace_back(std::make_unique<DownloadWorker>(this, i));
            m_workers.back()->start();
        }
    }

    std::cout << "Download started with " << m_workers.size() << " active threads." << std::endl;
    return true;
}
// ... 其他函数如 load_state, save_state, worker_thread_func 等后续实现

4.3 下载工作者 (DownloadWorker)

工作者线程类，执行具体的下载任务。

// download_worker.h
#ifndef DOWNLOAD_WORKER_H
#define DOWNLOAD_WORKER_H

#include <thread>
#include <atomic>
#include <string>

class DownloadManager;

class DownloadWorker {
public:
    DownloadWorker(DownloadManager* manager, int task_id);
    ~DownloadWorker();

    void start();
    void stop();
    bool is_running() const { return m_running; }

private:
    void run(); // 线程执行函数

    DownloadManager* m_manager;
    int m_task_id;
    std::thread m_thread;
    std::atomic<bool> m_running;
};

#endif // DOWNLOAD_WORKER_H

// download_worker.cpp
#include "download_worker.h"
#include "download_manager.h"
#include <cpr/cpr.h>
#include <fstream>
#include <iostream>

DownloadWorker::DownloadWorker(DownloadManager* manager, int task_id)
    : m_manager(manager), m_task_id(task_id), m_running(false) {}

void DownloadWorker::start() {
    if (m_running) return;
    m_running = true;
    m_thread = std::thread(&DownloadWorker::run, this);
}

void DownloadWorker::stop() {
    m_running = false;
    if (m_thread.joinable()) {
        m_thread.join();
    }
}

DownloadWorker::~DownloadWorker() {
    stop();
}

void DownloadWorker::run() {
    // 通过管理器获取任务并执行下载逻辑
    // 实际实现中，这里会调用 DownloadManager 的 worker_thread_func
    // 为了清晰，我们将核心下载逻辑放在 DownloadManager 中，由它来协调
    if (m_manager) {
        m_manager->worker_thread_func(m_task_id);
    }
}

5. 核心下载逻辑与线程同步

现在实现最核心的部分： DownloadManager::worker_thread_func 。这个函数由每个 DownloadWorker 线程调用，负责下载指定的分片。

// 在 download_manager.cpp 中继续实现
void DownloadManager::worker_thread_func(int task_id) {
    if (task_id < 0 || task_id >= m_tasks.size()) return;

    DownloadTask& task = m_tasks[task_id];
    {
        std::lock_guard<std::mutex> lock(m_tasks_mutex);
        task.status = TaskStatus::DOWNLOADING;
    }

    std::cout << "Thread for task " << task_id << " started. Range: "
              << task.start_byte << "-" << task.end_byte << std::endl;

    // 构建 Range 请求头
    std::string range_header = "bytes=" + std::to_string(task.start_byte + task.downloaded) + "-" + std::to_string(task.end_byte);

    // 打开临时文件，准备写入
    std::ofstream outfile(m_temp_file_path, std::ios::binary | std::ios::in | std::ios::out);
    if (!outfile) {
        std::cerr << "Task " << task_id << ": Failed to open temp file for writing." << std::endl;
        task.status = TaskStatus::FAILED;
        return;
    }
    // 定位到该分片应写入的起始位置
    outfile.seekp(task.start_byte + task.downloaded);

    try {
        // 发起带 Range 头的 GET 请求
        // cpr::WriteCallback 是一个可调用对象，每收到一段数据就调用一次
        auto write_callback = [&](cpr::DownloadCallbackData data) -> bool {
            if (!m_running || m_is_paused || m_is_stopped) {
                return false; // 中断下载
            }

            if (data.dlen > 0) {
                outfile.write(data.data, data.dlen);
                if (!outfile) {
                    std::cerr << "Task " << task_id << ": File write error." << std::endl;
                    return false;
                }
                // 原子地更新已下载字节数
                task.downloaded += data.dlen;

                // 可以在这里更新全局进度（需加锁或使用原子变量）
                // 例如，每下载 1MB 打印一次进度
                static long long last_print[10] = {0}; // 简单示例，实际需改进
                if (task.downloaded - last_print[task_id] > 1024 * 1024) {
                    std::lock_guard<std::mutex> lock(m_tasks_mutex); // 打印时加锁避免交错
                    std::cout << "Task " << task_id << " progress: " << task.progress() << "%" << std::endl;
                    last_print[task_id] = task.downloaded;
                }
            }
            return true; // 继续下载
        };

        cpr::Response response = cpr::Get(
            cpr::Url{m_url},
            cpr::Header{{"Range", range_header}},
            cpr::WriteCallback{write_callback},
            cpr::ProgressCallback{} // 也可以使用 ProgressCallback，但 WriteCallback 更灵活
            // cpr::Timeout 可以设置超时
        );

        outfile.close();

        {
            std::lock_guard<std::mutex> lock(m_tasks_mutex);
            if (response.status_code == 206 || response.status_code == 200) { // 206 Partial Content 或 200 OK (当不支持Range时)
                if (task.downloaded >= task.total_size) {
                    task.status = TaskStatus::COMPLETED;
                    std::cout << "Task " << task_id << " completed." << std::endl;
                } else {
                    // 可能被暂停或停止
                    task.status = TaskStatus::PENDING;
                    std::cout << "Task " << task_id << " paused at " << task.downloaded << " bytes." << std::endl;
                }
            } else {
                task.status = TaskStatus::FAILED;
                std::cerr << "Task " << task_id << " failed. HTTP " << response.status_code << std::endl;
            }
        }

        // 定期或在任务状态变更时保存状态
        save_state();

    } catch (const std::exception& e) {
        std::lock_guard<std::mutex> lock(m_tasks_mutex);
        task.status = TaskStatus::FAILED;
        std::cerr << "Task " << task_id << " exception: " << e.what() << std::endl;
        outfile.close();
    }
}

6. 状态持久化与进度管理

断点续传的关键是能将下载状态保存到磁盘，并在程序重启后恢复。

// download_manager.cpp 中的 load_state 和 save_state 实现
void DownloadManager::load_state() {
    std::ifstream state_file(m_state_file_path);
    if (!state_file.is_open()) {
        std::cout << "No previous state found, starting fresh download." << std::endl;
        return;
    }

    std::string line;
    while (std::getline(state_file, line)) {
        // 简单格式：task_id,downloaded_bytes
        std::istringstream iss(line);
        int id;
        long long downloaded;
        char comma;
        if (iss >> id >> comma >> downloaded) {
            if (id >= 0 && id < m_tasks.size()) {
                m_tasks[id].downloaded = downloaded;
                // 如果分片已下载完，标记为完成
                if (m_tasks[id].downloaded >= m_tasks[id].total_size) {
                    m_tasks[id].status = TaskStatus::COMPLETED;
                } else {
                    m_tasks[id].status = TaskStatus::PENDING;
                }
            }
        }
    }
    state_file.close();
    std::cout << "Previous download state loaded." << std::endl;
}

void DownloadManager::save_state() {
    std::lock_guard<std::mutex> lock(m_tasks_mutex); // 保存时需加锁，确保状态一致性
    std::ofstream state_file(m_state_file_path);
    if (!state_file.is_open()) {
        std::cerr << "Cannot open state file for writing: " << m_state_file_path << std::endl;
        return;
    }

    for (const auto& task : m_tasks) {
        state_file << task.task_id << "," << task.downloaded.load() << "\n";
    }
    state_file.close();
    // 可以优化为定时保存，而非每次进度更新都保存
}

7. 主程序与运行示例

最后，我们编写一个简单的主程序来使用这个下载管理器。

// main.cpp
#include "download_manager.h"
#include <iostream>
#include <csignal>
#include <atomic>

std::atomic<bool> g_stop_signal(false);

void signal_handler(int signal) {
    std::cout << "\nInterrupt signal received. Stopping download..." << std::endl;
    g_stop_signal = true;
}

int main(int argc, char* argv[]) {
    if (argc != 3) {
        std::cerr << "Usage: " << argv[0] << " <URL> <output_file>" << std::endl;
        return 1;
    }

    std::string url = argv[1];
    std::string output_file = argv[2];
    int num_threads = 4; // 默认4线程，可根据需要调整

    // 注册信号处理，支持 Ctrl+C 暂停/停止
    std::signal(SIGINT, signal_handler);

    DownloadManager manager(url, output_file, num_threads);

    std::cout << "Starting download..." << std::endl;
    if (!manager.start()) {
        std::cerr << "Failed to start download." << std::endl;
        return 1;
    }

    // 主循环，模拟UI或监控线程，定期打印总进度
    while (!g_stop_signal) {
        double progress = manager.get_overall_progress();
        std::cout << "\rOverall Progress: " << progress << "%" << std::flush;
        if (progress >= 100.0) {
            std::cout << "\nDownload completed successfully!" << std::endl;
            break;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }

    if (g_stop_signal) {
        std::cout << "\nUser requested stop. Pausing download..." << std::endl;
        manager.pause(); // 暂停会保存状态
        // manager.stop(); // 停止则清理，不可恢复
    }

    return 0;
}

编译与运行：

# 假设在项目根目录
mkdir build && cd build
cmake ..
make
# 运行下载器
./downloader "https://example.com/largefile.zip" "myfile.zip"

8. 常见问题与排查思路

在实现和使用这样一个下载器时，你可能会遇到以下问题：

9. 最佳实践与工程化建议

要将这个示例提升到生产可用级别，还需要考虑很多工程细节：

1. 连接池与超时控制 ：为每个 DownloadWorker 配置独立的连接参数（超时、重试），避免一个慢请求阻塞整体进度。
2. 流量控制与限速 ：实现全局或单线程的下载速度限制，避免占用过多带宽。
3. 更健壮的错误处理 ：区分网络错误、服务器错误（403, 404, 503）、磁盘错误，并采取不同重试策略。
4. 分片动态调整 ：如果某个分片下载失败多次，可以将其进一步拆分给其他线程，或标记为“困难分片”特殊处理。
5. 进度回调与事件通知 ：设计一个回调接口，让管理器可以将进度更新、状态变化（开始、暂停、完成、错误）通知给上层（如 UI）。
6. 支持更多协议 ：抽象出 ProtocolHandler 接口，便于扩展支持 FTP、HTTPS 甚至 BitTorrent。
7. 资源清理 ：确保在任何退出路径（正常、异常、信号中断）下，都能正确关闭文件描述符、停止线程、清理临时文件。
8. 单元测试 ：对分片计算、状态序列化、文件写入等核心逻辑编写单元测试。
9. 使用更高效的 I/O ：对于超大文件，可以考虑使用内存映射文件 ( mmap ) 来提升写入性能。

回到最初的面试题，一个出色的回答不应该止步于展示代码。你应该在解释完基本实现后，主动讨论这些 扩展性设计和边界情况 。这能充分展示你的工程思维和实战经验，让你从众多候选人中脱颖而出。这个项目本身也是一个极佳的练手项目，你可以基于这个框架不断添加新特性，深化对 C++ 并发和网络编程的理解。