C 程序多线程拆分文件

C 程序多线程拆分文件

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

在 Linux 下使用 pthread

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

1. #include <pthread.h>
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <unistd.h>
6. /*  定义线程的工作函数    */
7. void* split_file(void* arg) {
8.     int thread_id = *((int*)arg);
9.     FILE* src = fopen("source.txt", "rb");
10.     if (!src) {
11.         perror("Failed to open source file");
12.         return NULL;
13.     }
14.    
15.     fseek(src, 0, SEEK_END);
16.     long filesize = ftell(src);
17.     fseek(src, 0, SEEK_SET);
18.    
19.     long part_size = filesize / 2; // 简单分割为两半
20.     long start_pos = thread_id * part_size;
21.     long end_pos = (thread_id + 1) * part_size;
22.     if (thread_id == 1) end_pos = filesize; // 确保第二个部分读取剩余部分
23.    
24.     char filename[50];
25.     sprintf(filename, "part%d.txt", thread_id + 1);
26.     FILE* dest = fopen(filename, "wb");
27.     if (!dest) {
28.         perror("Failed to open destination file");
29.         fclose(src);
30.         return NULL;
31.     }
32.    
33.     fseek(src, start_pos, SEEK_SET);
34.     char buffer[1024];
35.     while (ftell(src) < end_pos) {
36.         size_t bytes_read = fread(buffer, 1, sizeof(buffer), src);
37.         fwrite(buffer, 1, bytes_read, dest);
38.     }
39.    
40.     fclose(src);
41.     fclose(dest);
42.     return NULL;
43. }
45. /*   主函数中创建和管理线程  */
46. int main() {
47.     pthread_t threads[2];
48.     int thread_ids[2] = {0, 1}; // 两个线程，分别处理文件的前半部和后半部
49.    
50.     for (int i = 0; i < 2; i++) {
51.         if (pthread_create(&threads[i], NULL, split_file, &thread_ids[i])) {
52.             fprintf(stderr, "Error creating thread\n");
53.             return 1;
54.         }
55.     }
56.    
57.     for (int i = 0; i < 2; i++) {
58.         pthread_join(threads[i], NULL);
59.     }
60.    
61.     printf("File split successfully.\n");
62.     return 0;
63. }

复制代码

在 Windows下使用 CreateThread

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

1. #include <windows.h>
2. #include <stdio.h>
3. #include <stdlib.h>
5. /*   定义线程函数   */
6. DWORD WINAPI SplitFile(LPVOID lpParam) {
7.     // 定义结构体传递参数
8.     struct ThreadParams {
9.         const char* inputFilePath;
10.         const char* outputFilePath;
11.         long startPos;
12.         long length;
13.     };
15.     // 类型转换参数
16.     ThreadParams* params = (ThreadParams*)lpParam;
18.     // 打开输入文件和输出文件
19.     FILE* inputFile = fopen(params->inputFilePath, "rb");
20.     FILE* outputFile = fopen(params->outputFilePath, "wb");
21.     if (inputFile == NULL || outputFile == NULL) {
22.         printf("Error opening file\n");
23.         return -1;
24.     }
26.     // 移动到开始位置并读取数据
27.     fseek(inputFile, params->startPos, SEEK_SET);
28.     char buffer[1024]; // 定义缓冲区大小
29.     long bytesRead;
30.     for (long pos = params->startPos; pos < params->startPos + params->length; pos += bytesRead) {
31.         bytesRead = fread(buffer, 1, sizeof(buffer), inputFile);
32.         if (bytesRead > 0) {
33.             fwrite(buffer, 1, bytesRead, outputFile);
34.         } else {
35.             break; // 文件结束或出错时退出循环
36.         }
37.     }
39.     // 关闭文件
40.     fclose(inputFile);
41.     fclose(outputFile);
42.     return 0;
43. }
46. /* 主函数中创建线程并传递参数
47. 在主函数中，你需要创建多个线程，每个线程处理文件的一部分。你需要计算每个线程应该处理的起始位置和长度  **/
48. int main() {
49.     const char* inputFilePath = "largefile.dat";  // 大文件路径
50.     long fileSize; // 文件大小，单位：字节
51.     FILE* file = fopen(inputFilePath, "rb");
52.     if (file == NULL) {
53.         printf("Error opening file\n");
54.         return -1;
55.     }
56.     fseek(file, 0, SEEK_END); // 移动到文件末尾以获取大小
57.     fileSize = ftell(file);   // 获取文件大小（字节）
58.     fclose(file);            // 关闭文件句柄，因为不再需要它读取文件大小了
60.     int numThreads = 4; // 使用4个线程进行拆分，可根据需要调整数量
61.     long partSize = fileSize / numThreads; // 每部分的大小（字节）
62.     HANDLE threads[numThreads]; // 线程句柄数组
63.     struct ThreadParams params[numThreads]; // 参数数组
64.   
65.     for (int i = 0; i < numThreads; i++) {
66.         params[i].inputFilePath = inputFilePath;
67.         params[i].outputFilePath = malloc(256); // 为每个输出文件分配路径字符串空间（例如：part1.dat, part2.dat等）
68.         sprintf(params[i].outputFilePath, "part%d.dat", i + 1); // 设置输出文件名
69.         params[i].startPos = i * partSize; // 计算开始位置
70.         params[i].length = (i == numThreads - 1) ? fileSize - params[i].startPos : partSize; // 最后一部分可能需要调整长度以覆盖剩余部分
71.         threads[i] = CreateThread(NULL, 0, SplitFile, &params[i], 0, NULL); // 创建线程并传递参数
72.     }
73.   
74.     // 等待所有线程完成
75.     WaitForMultipleObjects(numThreads, threads, TRUE, INFINITE); // 等待所有线程完成执行。TRUE表示等待所有对象。INFINITE表示无限等待。
76.   
77.     // 清理资源（关闭句柄）和释放分配的内存空间等操作。这里省略具体实现，实际应用中需要
78. }

复制代码

附件一：多线程上风

线程程序作为一种多任务、并发的工作方式，当然有其存在上风：
进步应用程序响应：
这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技能，将耗时长的操作（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。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。