多线程文件搜索 2023/7/19-CSDN博客

本文链接：https://blog.csdn.net/m0_52174744/article/details/131816293

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

#define MAX_PATH_LENGTH 1024
#define NUM_THREADS 6

typedef struct {
    char path[MAX_PATH_LENGTH];
    int file_count;
    int dir_count;
    pthread_mutex_t count_mutex;
    int thread_id;
} ThreadData;

pthread_mutex_t path_mutex;
char search_paths[MAX_PATH_LENGTH][MAX_PATH_LENGTH];
int search_path_count = 0;
int current_search_path = 0;

void enqueue_path(const char* path) {
    pthread_mutex_lock(&path_mutex);
    if (search_path_count < MAX_PATH_LENGTH) {
        strcpy(search_paths[search_path_count], path);
        search_path_count++;
    }
    pthread_mutex_unlock(&path_mutex);
}

char* dequeue_path() {
    pthread_mutex_lock(&path_mutex);
    if (current_search_path >= search_path_count) {
        pthread_mutex_unlock(&path_mutex);
        return NULL;
    }
    char* path = search_paths[current_search_path];
    current_search_path++;
    pthread_mutex_unlock(&path_mutex);

    return path;
}

void* search_directory(void* data) {
    ThreadData* thread_data = (ThreadData*)data;
    char directory_path[MAX_PATH_LENGTH];
    int thread_id = thread_data->thread_id;

    while (1) {
        char* current_path = dequeue_path();
        if (current_path == NULL) {
            break;
        }

        strcpy(directory_path, current_path);
        DIR* directory;
        struct dirent* entry;

        directory = opendir(directory_path);
        if (directory == NULL) {
            perror("无法打开目录");
            pthread_exit(NULL);
        }

        int local_file_count = 0;
        int local_dir_count = 0;

        while ((entry = readdir(directory)) != NULL) {
            if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
                continue;
            }

            char full_path[MAX_PATH_LENGTH];
            snprintf(full_path, sizeof(full_path), "%s/%s", directory_path, entry->d_name);

            if (entry->d_type == DT_DIR) {
                local_dir_count++;
                enqueue_path(full_path);

                printf("线程 %d 搜索到目录：%s\n", thread_id, full_path);
            } else if (entry->d_type == DT_REG) {
                local_file_count++;
                printf("线程 %d 搜索到文件：%s\n", thread_id, full_path);
            }
        }

        pthread_mutex_lock(&thread_data->count_mutex);
        thread_data->file_count += local_file_count;
        thread_data->dir_count += local_dir_count;
        pthread_mutex_unlock(&thread_data->count_mutex);

        closedir(directory);
    }

    pthread_exit(NULL);
}

int main() {
    const char* start_path = "/home/zhengxy/00_makefile_file";
    pthread_t threads[NUM_THREADS];
    ThreadData thread_data[NUM_THREADS];
    pthread_mutex_init(&path_mutex, NULL);

    enqueue_path(start_path);

    int thread_ids[NUM_THREADS];
    int i;
    for (i = 0; i < NUM_THREADS; i++) {
        thread_ids[i] = i + 1;
        thread_data[i].file_count = 0;
        thread_data[i].dir_count = 0;
        pthread_mutex_init(&thread_data[i].count_mutex, NULL);
        thread_data[i].thread_id = thread_ids[i];
        pthread_create(&threads[i], NULL, search_directory, &thread_data[i]);
    }

    for (i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
        pthread_mutex_destroy(&thread_data[i].count_mutex);
    }

    pthread_mutex_destroy(&path_mutex);

    // 打印每个线程搜索的文件和目录数量
    printf("========\n");
    for (i = 0; i < NUM_THREADS; i++) {
        printf("线程 %d 搜索的文件数量: %d\n", thread_data[i].thread_id, thread_data[i].file_count);
        printf("线程 %d 搜索的目录数量: %d\n", thread_data[i].thread_id, thread_data[i].dir_count);
    }

    return 0;
}

1. 首先，在代码的开头，我们定义了需要使用的预处理宏和常量。其中 `MAX_PATH_LENGTH` 是路径的最大长度，`NUM_THREADS` 是要创建的线程数。

2. 接下来定义了一个 `ThreadData` 结构体，用于存储每个线程的相关信息，包括路径、文件数量、目录数量、互斥锁和线程 ID。

3. 定义了全局变量 `path_mutex` 用于对搜索路径进行加锁，`search_paths` 用于存储搜索路径的数组，`search_path_count` 表示实际存储的搜索路径数量，`current_search_path` 表示当前正在搜索的路径索引。

4. `enqueue_path(const char* path)` 函数用于将路径添加到搜索队列中，使用互斥锁保证线程安全。

5. `dequeue_path()` 函数用于从搜索队列中取出一个路径，使用互斥锁保证线程安全。

6. `search_directory(void* data)` 函数是线程函数，用于在指定目录下递归地搜索文件和目录。每个线程负责从搜索队列中获取路径，并进行搜索。在搜索时，若遇到子目录，则将其加入搜索队列，并打印出来。若遇到文件，则增加计数并打印出来。

7. 在 `main()` 函数中，首先初始化互斥锁 `path_mutex`。

8. 将起始路径（在此示例中为当前目录）添加到搜索队列中。

9. 创建指定数量的线程，每个线程拥有一个独立的线程 ID。同时初始化线程的相关信息，包括文件数量、目录数量、互斥锁和线程 ID。创建线程后，每个线程调用 `search_directory()` 函数进行搜索。

10. 主线程使用 `pthread_join()` 等待所有子线程的结束。

11. 最后，主线程销毁各个线程的互斥锁，打印出每个线程搜索到的文件和目录数量。

执行流程：