Linux copendir在多线程环境下如何使用

在多线程环境下使用 copirdir 函数，需要考虑线程安全和同步问题。copirdir 是一个用于复制目录及其内容的函数，通常在 POSIX 系统上可用。以下是一个基本的示例，展示如何在多线程环境中安全地使用 copirdir。

首先，确保你有一个线程安全的 copirdir 实现。你可以使用 POSIX 线程（pthreads）库来实现这一点。以下是一个简单的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <sys/stat.h>
#include <pthread.h>

// 线程安全的全局变量
pthread_mutex_t lock;

// 复制文件或目录的函数
int copy_item(const char *src, const char *dest) {
    struct stat st;
    if (stat(src, &st) == -1) {
        perror("stat");
        return -1;
    }

    if (S_ISDIR(st.st_mode)) {
        // 创建目标目录
        if (mkdir(dest, st.st_mode) == -1) {
            perror("mkdir");
            return -1;
        }

        // 打开源目录
        DIR *dir = opendir(src);
        if (!dir) {
            perror("opendir");
            return -1;
        }

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

            char src_path[1024], dest_path[1024];
            snprintf(src_path, sizeof(src_path), "%s/%s", src, entry->d_name);
            snprintf(dest_path, sizeof(dest_path), "%s/%s", dest, entry->d_name);

            // 递归复制子目录或文件
            if (copy_item(src_path, dest_path) != 0) {
                closedir(dir);
                return -1;
            }
        }

        closedir(dir);
    } else {
        // 复制文件
        FILE *src_file = fopen(src, "rb");
        if (!src_file) {
            perror("fopen");
            return -1;
        }

        FILE *dest_file = fopen(dest, "wb");
        if (!dest_file) {
            perror("fopen");
            fclose(src_file);
            return -1;
        }

        char buffer[1024];
        size_t bytes_read;
        while ((bytes_read = fread(buffer, 1, sizeof(buffer), src_file)) > 0) {
            if (fwrite(buffer, 1, bytes_read, dest_file) != bytes_read) {
                perror("fwrite");
                fclose(src_file);
                fclose(dest_file);
                return -1;
            }
        }

        fclose(src_file);
        fclose(dest_file);
    }

    return 0;
}

// 线程函数
void *thread_func(void *arg) {
    const char *src = (const char *)arg;
    const char *dest = "destination_directory"; // 目标目录

    pthread_mutex_lock(&lock);
    if (copy_item(src, dest) != 0) {
        fprintf(stderr, "Failed to copy directory: %s\n", src);
    }
    pthread_mutex_unlock(&lock);

    return NULL;
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <source_directory>\n", argv[0]);
        return 1;
    }

    const char *src_dir = argv[1];

    // 初始化互斥锁
    if (pthread_mutex_init(&lock, NULL) != 0) {
        perror("pthread_mutex_init");
        return 1;
    }

    // 创建线程
    pthread_t thread;
    if (pthread_create(&thread, NULL, thread_func, (void *)src_dir) != 0) {
        perror("pthread_create");
        pthread_mutex_destroy(&lock);
        return 1;
    }

    // 等待线程结束
    pthread_join(thread, NULL);

    // 销毁互斥锁
    pthread_mutex_destroy(&lock);

    return 0;
}

在这个示例中，我们使用了一个互斥锁 pthread_mutex_t 来确保在多线程环境下对 copy_item 函数的调用是线程安全的。每个线程在调用 copy_item 之前都会锁定互斥锁，并在调用完成后解锁。

请注意，这个示例假设目标目录已经存在。如果目标目录不存在，你需要在程序开始时创建它，或者在 copy_item 函数中添加创建目标目录的逻辑。

编译这个程序时，你需要链接 pthread 库：

gcc -o copirdir_example copirdir_example.c -lpthread

运行这个程序时，传入源目录作为参数：

./copirdir_example source_directory

这个程序会在目标目录中复制源目录及其内容。