如何用readdir实现多线程目录遍历

使用 readdir 实现多线程目录遍历可以提高程序的性能，特别是在处理大型目录结构时。下面是一个使用 C 语言和 POSIX 线程（pthreads）实现的示例代码，展示如何通过多线程来遍历目录。

示例代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <pthread.h>

// 定义一个结构体来传递参数给线程
typedef struct {
    char *path;
} ThreadData;

// 线程函数：遍历一个目录
void* traverse_directory(void *arg) {
    ThreadData *data = (ThreadData*) arg;
    DIR *dir = opendir(data->path);
    if (dir == NULL) {
        perror("opendir");
        pthread_exit(NULL);
    }

    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        // 跳过当前目录和上级目录
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
            continue;

        // 构建完整的路径
        char full_path[1024];
        snprintf(full_path, sizeof(full_path), "%s/%s", data->path, entry->d_name);

        // 打印文件或目录名
        printf("%s\n", full_path);

        // 如果是目录，则创建一个新线程来遍历它
        if (entry->d_type == DT_DIR) {
            pthread_t thread;
            ThreadData *new_data = malloc(sizeof(ThreadData));
            if (new_data == NULL) {
                perror("malloc");
                closedir(dir);
                pthread_exit(NULL);
            }
            new_data->path = full_path;
            if (pthread_create(&thread, NULL, traverse_directory, (void*) new_data) != 0) {
                perror("pthread_create");
                free(new_data);
                closedir(dir);
                pthread_exit(NULL);
            }
            // 分离线程，避免资源泄漏
            pthread_detach(thread);
        }
    }

    closedir(dir);
    pthread_exit(NULL);
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "用法: %s <目录路径>\n", argv[0]);
        return EXIT_FAILURE;
    }

    pthread_t main_thread;
    if (pthread_create(&main_thread, NULL, traverse_directory, (void*) argv[1]) != 0) {
        perror("pthread_create");
        return EXIT_FAILURE;
    }

    // 等待主线程结束
    pthread_join(main_thread, NULL);
    return EXIT_SUCCESS;
}

代码说明

1. 结构体定义:

   • ThreadData 结构体用于在线程之间传递参数，这里传递的是要遍历的目录路径。

2. 线程函数 traverse_directory:

   • 接受一个 void* 类型的参数，并将其转换为 ThreadData*。
   • 使用 opendir 打开目录，使用 readdir 读取目录项。
   • 对于每个目录项，构建完整的路径并打印。
   • 如果遇到子目录（DT_DIR），则分配新的 ThreadData 并创建一个新线程来遍历该子目录。
   • 使用 pthread_detach 分离线程，这样当线程结束时，资源会自动释放。

3. 主函数 main:

   • 检查命令行参数，确保提供了一个目录路径。
   • 创建主线程，开始遍历指定的根目录。
   • 使用 pthread_join 等待主线程结束，确保程序不会提前退出。

注意事项

• 线程数量: 上述示例中，每个子目录都会创建一个新的线程。这在目录层级较深或子目录数量较多时，可能会导致大量线程被创建，进而消耗大量系统资源甚至导致程序崩溃。可以通过限制同时运行的线程数量（例如使用线程池）来优化性能。

• 错误处理: 示例中对一些可能的错误进行了基本处理，但在生产代码中应更加全面地处理各种可能的错误情况。

• 同步机制: 如果需要在多个线程之间共享数据或进行更复杂的同步操作，可能需要使用互斥锁（mutex）、信号量（semaphore）等同步机制来避免竞态条件。

使用线程池优化

为了避免创建过多的线程，可以使用线程池来限制同时运行的线程数量。以下是使用 POSIX 线程池（pthreadpool）的一个简单示例：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <pthread.h>
#include <pthreadpool.h>

typedef struct {
    char *path;
} ThreadData;

void* traverse_directory(void *arg) {
    ThreadData *data = (ThreadData*) arg;
    DIR *dir = opendir(data->path);
    if (dir == NULL) {
        perror("opendir");
        pthread_exit(NULL);
    }

    struct dirent *entry;
    while ((entry = readdir(dir)) != NULL) {
        if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
            continue;

        char full_path[1024];
        snprintf(full_path, sizeof(full_path), "%s/%s", data->path, entry->d_name);

        printf("%s\n", full_path);

        if (entry->d_type == DT_DIR) {
            pthreadpool_t pool = pthreadpool_create(10); // 创建一个最多有10个线程的线程池
            ThreadData *new_data = malloc(sizeof(ThreadData));
            if (new_data == NULL) {
                perror("malloc");
                closedir(dir);
                pthread_exit(NULL);
            }
            new_data->path = full_path;
            pthreadpool_create_tasks(pool, (void *(*)(void *)) traverse_directory, (void*) new_data);
            pthreadpool_destroy(pool);
        }
    }

    closedir(dir);
    pthread_exit(NULL);
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "用法: %s <目录路径>\n", argv[0]);
        return EXIT_FAILURE;
    }

    pthread_t main_thread;
    pthreadpool_t pool = pthreadpool_create(10); // 创建一个最多有10个线程的线程池

    ThreadData *initial_data = malloc(sizeof(ThreadData));
    if (initial_data == NULL) {
        perror("malloc");
        pthreadpool_destroy(pool);
        return EXIT_FAILURE;
    }
    initial_data->path = argv[1];

    pthreadpool_create_tasks(pool, (void *(*)(void *)) traverse_directory, (void*) initial_data);
    pthreadpool_destroy(pool);

    pthread_exit(NULL);
}

使用线程池的说明

• 线程池创建: 使用 pthreadpool_create 创建一个线程池，并指定最大线程数（例如 10）。
• 任务提交: 使用 pthreadpool_create_tasks 将遍历子目录的任务提交到线程池中执行。
• 线程池销毁: 在所有任务完成后，使用 pthreadpool_destroy 销毁线程池。

这种方法可以有效限制同时运行的线程数量，避免因创建过多线程而导致的资源耗尽问题。

总结

通过使用多线程和适当的同步机制，可以显著提高目录遍历的效率。然而，需要注意线程管理和资源控制，以确保程序的稳定性和性能。根据具体需求选择合适的并发模型和优化策略。