Python多线程拷贝源文件夹到多个目标目录下

方案一： 直接套用脚本，需可以看懂一些脚本逻辑

在该代码中，我们对 copy_folder() 函数进行了修改，如果目标文件夹已经存在，则先清空目标文件夹，然后再进行复制。为了清除目标文件夹，我们使用了 shutil.rmtree() 方法，它会递归删除目标文件夹中的所有内容，包括文件和子文件夹。

在主程序中，我们与之前的代码是一样的，先计算每个线程需要拷贝的目标文件夹数量，然后创建多个线程，每个线程处理一部分目标文件夹的拷贝工作。最后，我们依次启动所有线程，等待它们全部执行完毕。我们在主程序中添加了代码用于记录开始时间和结束时间，并输出用时。通过 time.time() 方法获取当前时间戳，并计算时间差来得到拷贝用时。

该程序与之前的代码是一样的，先计算每个线程需要拷贝的目标文件夹数量，然后创建多个线程，每个线程处理一部分目标文件夹的拷贝工作。最后，我们依次启动所有线程，等待它们全部执行完毕。在所有线程结束后，我们记录结束时间，并输出用时

import shutil
import os
import threading
import time

def copy_folder(source_folder, dest_folders):
    """
    将文件夹 source_folder 复制到多个目标文件夹 dest_folders。
    如果目标文件夹已经存在，则先清空目标文件夹，然后复制。
    """
    for dest_folder in dest_folders:
        try:
            if os.path.exists(dest_folder):
                shutil.rmtree(dest_folder)
            shutil.copytree(source_folder, dest_folder)
            print(f"成功将 {source_folder} 复制到 {dest_folder}")
        except Exception as e:
            print(f"复制 {source_folder} 到 {dest_folder} 时发生错误:e}")

if __name__ == "__main__":
    # 需要复制的原始文件夹
    source_folder = "/path/to/source/folder"
    
    # 需要复制到的多个目标文件夹
    dest_folders = ["/folder_1", "/folder_2", "/folder_3"]
    
    # 计算每个线程需要拷贝的目标文件夹数量
    threads_num = len(dest_folders)
    folders_per_thread = len(dest_folders) // threads_num
    
    # 创建线程列表
    threads = []
    for i in range(threads_num):
        start = i * folders_per_thread
        end = start + folders_per_thread
        if i == threads_num - 1:
            end = len(dest_folders)
        thread = threading.Thread(target=copy_folder, args=(source_folder, dest_folders[start:end]))
        threads.append(thread)
    
    # 记录开始时间
    start_time = time.time()
    
    # 启动所有线程
    for thread in threads:
        thread.start()
    
    # 等待所有线程结束
    for thread in threads:
        thread.join()
    
    # 记录结束时间并输出用时
    end_time = time.time()
    print(f"复制用时: {end_time - start_time} 秒")

方案二：直接调用封装脚本（写用例，执行脚本即可）

脚本实现封装后，只需要在ThreadProcessCopy.yaml文件中写用例即可，此后执行Threadprocess_Copy.py脚本即实现多线程拷贝文件夹下所有内容到指定目录

目录介绍：

ThreadProcessCopy.yaml配置拷贝文件的源地址和目标地址

source_folder: 原始文件夹路径

dest_folders: 需存放目标文件夹，可多个同时填写

ThreadingProcess:
  source_folder: \\127.0.0.1\d$\exportdir
  dest_folders:
    - \\127.0.0.2\d$\dir
    - \\127.0.0.3\d$\dir

PublicConfig.py脚本： 配置读取信息，方便调用

import os
from Public_Utils.util_yaml import YamlReader

class YamlPath:
    def __init__(self):
        current = os.path.abspath(__file__)
        self.base_dir = os.path.dirname(os.path.dirname(current))

    def get_threadprocess_file(self):
        _config_path = self.base_dir + os.sep + "Public_Config\Public_yaml"
        self._config_file = _config_path + os.sep + "ThreadProcessCopy.yaml"
        return self._config_file

class ConfigYaml:
    def __init__(self):   #初始yaml读取配置文件
        self.threadprocess_config = YamlReader(YamlPath().get_threadprocess_file()).yaml_data()

    def get_threadprocess_yaml(self):
        return self.threadprocess_config['ThreadingProcess']

if __name__ == '__main__':
    pass

Threadprocess_Copy.py执行脚本

import os
import shutil
import threading
import time
from Public_Config.PublicConfig import ConfigYaml

class ThreadProcess:

    def copy_folder(self,source_folder,dest_folders):
        """
        将原文件夹复制到多个目标文件夹下
        :return:
        """
        for dest_folder in dest_folders:
            try:
                if os.path.exists(dest_folder):
                    shutil.rmtree(dest_folder)
                shutil.copytree(source_folder,dest_folder)
                print(f"has copied {source_folder} to {dest_folder}")
            except Exception as e:
                print(f"failed copy {e}")

    def Thread_copy_folder(self):   #多线程同时拷贝源文件夹到其他多个目录
        source_folder = ConfigYaml().get_threadprocess_yaml()['source_folder']  # 需要复制的原始文件夹
        dest_folders = ConfigYaml().get_threadprocess_yaml()['dest_folders']  # 需要复制到的目标文件夹
        #计算每个线程需要拷贝第目标文件夹数量
        threads_num = len(dest_folders)
        folders_per_thread = len(dest_folders) // threads_num
        #创建线程列表
        threads = []
        for i in range(threads_num):
            start = i * folders_per_thread
            end = start + folders_per_thread
            if i == threads_num - 1:
                end = len(dest_folders)
            thread = threading.Thread(target=self.copy_folder, args=(source_folder, dest_folders[start:end]))
            threads.append(thread)
        #记录开始时间
        start_time = time.time()
        # 启动所有线程
        for thread in threads:
            thread.start()
        # 等待所有线程结束
        for thread in threads:
            thread.join()
        # 结束时间
        end_time = time.time()
        print(f"复制用时{end_time - start_time}")

if __name__ == '__main__':
    ThreadProcess().Thread_copy_folder()
    pass

util_yaml.py

import os
import yaml

class YamlReader:
    #初始化，判断文件是否存在
    def __init__(self,yaml_file):
        if os.path.exists(yaml_file):
            self.yaml_file = yaml_file
        else:
            raise FileNotFoundError("yaml文件不存在")
        self._data = None
        self._data_all = None

    def yaml_data(self):  #yaml文件读取 --单个文档读取
        #第一次调用data,读取yaml文档，如果不是，直接返回之前保存的数据
        if not self._data:
            with open(self.yaml_file,'rb') as f:
                self._data = yaml.safe_load(f)
        return self._data

    def yaml_data_all(self):  #多个文档的读取
        if not self._data_all:
            with open(self.yaml_file,'rb') as f:
                self._data_all = yaml.safe_load_all(f)
        return self._data_all