C 程序多线程拆分文件

C 程序多线程拆分文件

在C语言中，实现多线程来拆分文件通常需要借助多线程库，比如 POSIX 线程库（pthread）或者 Windows 的线程库（CreateThread 或类似的函数）。下面我将分别展示在 Linux 和 Windows 环境下使用这两种方式拆分文件的示例。

在 Linux 下使用 pthread

首先，确保你的系统支持 POSIX 线程

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

/*  定义线程的工作函数    */
void* split_file(void* arg) {
    int thread_id = *((int*)arg);
    FILE* src = fopen("source.txt", "rb");
    if (!src) {
        perror("Failed to open source file");
        return NULL;
    }
    
    fseek(src, 0, SEEK_END);
    long filesize = ftell(src);
    fseek(src, 0, SEEK_SET);
    
    long part_size = filesize / 2; // 简单分割为两半
    long start_pos = thread_id * part_size;
    long end_pos = (thread_id + 1) * part_size;
    if (thread_id == 1) end_pos = filesize; // 确保第二个部分读取剩余部分
    
    char filename[50];
    sprintf(filename, "part%d.txt", thread_id + 1);
    FILE* dest = fopen(filename, "wb");
    if (!dest) {
        perror("Failed to open destination file");
        fclose(src);
        return NULL;
    }
    
    fseek(src, start_pos, SEEK_SET);
    char buffer[1024];
    while (ftell(src) < end_pos) {
        size_t bytes_read = fread(buffer, 1, sizeof(buffer), src);
        fwrite(buffer, 1, bytes_read, dest);
    }
    
    fclose(src);
    fclose(dest);
    return NULL;
}

/*   主函数中创建和管理线程  */
int main() {
    pthread_t threads[2];
    int thread_ids[2] = {0, 1}; // 两个线程，分别处理文件的前半部和后半部
    
    for (int i = 0; i < 2; i++) {
        if (pthread_create(&threads[i], NULL, split_file, &thread_ids[i])) {
            fprintf(stderr, "Error creating thread\n");
            return 1;
        }
    }
    
    for (int i = 0; i < 2; i++) {
        pthread_join(threads[i], NULL);
    }
    
    printf("File split successfully.\n");
    return 0;
}

在 Windows下使用 CreateThread

在Windows环境下，使用CreateThread函数来实现多线程拆分文件是一种常见的方法。CreateThread函数是Windows API的一部分，用于创建一个新的线程。下面，我将详细介绍如何使用CreateThread来实现一个简单的文件拆分程序。

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

/*   定义线程函数   */
DWORD WINAPI SplitFile(LPVOID lpParam) {
    // 定义结构体传递参数
    struct ThreadParams {
        const char* inputFilePath;
        const char* outputFilePath;
        long startPos;
        long length;
    };
 
    // 类型转换参数
    ThreadParams* params = (ThreadParams*)lpParam;
 
    // 打开输入文件和输出文件
    FILE* inputFile = fopen(params->inputFilePath, "rb");
    FILE* outputFile = fopen(params->outputFilePath, "wb");
    if (inputFile == NULL || outputFile == NULL) {
        printf("Error opening file\n");
        return -1;
    }
 
    // 移动到开始位置并读取数据
    fseek(inputFile, params->startPos, SEEK_SET);
    char buffer[1024]; // 定义缓冲区大小
    long bytesRead;
    for (long pos = params->startPos; pos < params->startPos + params->length; pos += bytesRead) {
        bytesRead = fread(buffer, 1, sizeof(buffer), inputFile);
        if (bytesRead > 0) {
            fwrite(buffer, 1, bytesRead, outputFile);
        } else {
            break; // 文件结束或出错时退出循环
        }
    }
 
    // 关闭文件
    fclose(inputFile);
    fclose(outputFile);
    return 0;
}


/* 主函数中创建线程并传递参数
在主函数中，你需要创建多个线程，每个线程处理文件的一部分。你需要计算每个线程应该处理的起始位置和长度  **/
int main() {
    const char* inputFilePath = "largefile.dat";  // 大文件路径
    long fileSize; // 文件大小，单位：字节
    FILE* file = fopen(inputFilePath, "rb");
    if (file == NULL) {
        printf("Error opening file\n");
        return -1;
    }
    fseek(file, 0, SEEK_END); // 移动到文件末尾以获取大小
    fileSize = ftell(file);   // 获取文件大小（字节）
    fclose(file);            // 关闭文件句柄，因为不再需要它读取文件大小了
 
    int numThreads = 4; // 使用4个线程进行拆分，可根据需要调整数量
    long partSize = fileSize / numThreads; // 每部分的大小（字节）
    HANDLE threads[numThreads]; // 线程句柄数组
    struct ThreadParams params[numThreads]; // 参数数组
  
    for (int i = 0; i < numThreads; i++) {
        params[i].inputFilePath = inputFilePath;
        params[i].outputFilePath = malloc(256); // 为每个输出文件分配路径字符串空间（例如：part1.dat, part2.dat等）
        sprintf(params[i].outputFilePath, "part%d.dat", i + 1); // 设置输出文件名
        params[i].startPos = i * partSize; // 计算开始位置
        params[i].length = (i == numThreads - 1) ? fileSize - params[i].startPos : partSize; // 最后一部分可能需要调整长度以覆盖剩余部分
        threads[i] = CreateThread(NULL, 0, SplitFile, &params[i], 0, NULL); // 创建线程并传递参数
    }
  
    // 等待所有线程完成
    WaitForMultipleObjects(numThreads, threads, TRUE, INFINITE); // 等待所有线程完成执行。TRUE表示等待所有对象。INFINITE表示无限等待。
  
    // 清理资源（关闭句柄）和释放分配的内存空间等操作。这里省略具体实现，实际应用中需要
}

附件一：多线程优势

线程程序作为一种多任务、并发的工作方式，当然有其存在优势：

提高应用程序响应：

这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。

使多CPU系统更加有效：

操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。

改善程序结构：

一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

附件二：操作步骤

线程创建

函数原型：int pthread_create(pthread_t*restrict tidp,const pthread_attr_t *restrict attr,void *(*start_rtn)(void),void *restrict arg);

返回值：若是成功建立线程返回0，否则返回错误的编号。

形式参数：pthread_t*restrict tidp要创建的线程的线程id指针；const pthread_attr_t *restrict attr创建线程时的线程属性；void *(start_rtn)(void)返回值是void类型的指针函数；void *restrict arg start_rtn的形参。

线程挂起：该函数的作用使得当前线程挂起，等待另一个线程返回才继续执行。也就是说当程序运行到这个地方时，程序会先停止，然后等线程id为thread的这个线程返回，然后程序才会断续执行。

函数原型：intpthread_join(pthread_tthread, void **value_ptr);

参数说明如下：thread等待退出线程的线程号；value_ptr退出线程的返回值。

返回值：若成功，则返回0；若失败，则返回错误号。

线程退出

函数原型：voidpthread_exit(void *rval_ptr);

获取当前线程id

函数原型：pthread_t pthread_self(void);

互斥锁

创建pthread_mutex_init；销毁pthread_mutex_destroy；加锁pthread_mutex_lock；解锁pthread_mutex_unlock。

条件锁

创建pthread_cond_init；销毁pthread_cond_destroy；触发pthread_cond_signal；广播pthread_cond_broadcast；等待pthread_cond_wait。