python 多线程拷贝单个文件

 # -*- coding: utf-8 -*-
 # @author: Tele
 # @Time  : 2019/04/04 下午 12:25
 # 多线程方式拷贝单个文件
 import threading
 import os
 import math

 rs = open("F:/ftp_mypc/a.flv", "rb")
 # 62919061 60MB
 file_size = os.path.getsize("F:/ftp_mypc/a.flv")
 if os.path.exists("f:/b/b.flv"):
     os.remove("f:/b/b.flv")
 ws = open("f:/b/b.flv", "ab")
 mutex = threading.Lock()
 total_count = 0

 def copy(start, byte_size):
     # print(threading.current_thread().getName())
     mutex.acquire()
     buffer = 1024
     count = 0
     rs.seek(start)
     ws.seek(start)
     while True:
         if count + buffer <= byte_size:
             content = rs.read(buffer)
             count += len(content)
             write(content)
         else:
             content = rs.read(byte_size % buffer)
             count += len(content)
             write(content)
             break
     global total_count
     total_count += byte_size
     print("\r拷贝进度为%.2f %%" % (total_count * 100 / file_size), end="")
     mutex.release()

 def write(content):
     ws.write(content)
     ws.flush()

 def main():
     # 每个线程拷贝的字节大小
     per_thread_size = 30000000
     for i in range(math.ceil(file_size / per_thread_size)):
         byte_size = per_thread_size
         if i == math.ceil(file_size / per_thread_size) - 1:
             byte_size = file_size % per_thread_size
         start = i * per_thread_size + i
         t = threading.Thread(target=copy, args=(start, byte_size))
         t.start()

     # t1 = threading.Thread(target=copy, args=(0, 30000000))
     # t2 = threading.Thread(target=copy, args=(30000001, 30000000))
     # t3 = threading.Thread(target=copy, args=(60000002, 2919061))
     # t1.start()
     # t2.start()
     # t3.start()

     # 子线程都结束后,释放资源
     if threading.activeCount() == 1:
         if ws:
             ws.close()
         if rs:
             rs.close()

 if __name__ == '__main__':
     main()

使用线程池:

 # -*- coding: utf-8 -*-
 # @author: Tele
 # @Time  : 2019/04/04 下午 12:25
 # 多线程方式拷贝单个文件,使用concurrent.futures.ThreadPoolExecutor线程池
 import threading
 import os
 import math
 from concurrent.futures import ThreadPoolExecutor, wait

 rs = open("F:/ftp_mypc/a.flv", "rb")
 # 62919061 60MB
 file_size = os.path.getsize("F:/ftp_mypc/a.flv")
 if os.path.exists("f:/b/b.flv"):
     os.remove("f:/b/b.flv")
 ws = open("f:/b/b.flv", "ab")
 mutex = threading.Lock()
 total_count = 0

 def copy(start, byte_size):
     # print(threading.current_thread().getName())
     mutex.acquire()
     buffer = 1024
     count = 0
     rs.seek(start)
     ws.seek(start)
     while True:
         if count + buffer <= byte_size:
             content = rs.read(buffer)
             count += len(content)
             write(content)
         else:
             content = rs.read(byte_size % buffer)
             count += len(content)
             write(content)
             break
     global total_count
     total_count += byte_size
     print("\r拷贝进度为%.2f %%" % (total_count * 100 / file_size), end="")
     mutex.release()

 def write(content):
     ws.write(content)
     ws.flush()

 def main():
     # 创建线程池
     executor = ThreadPoolExecutor(max_workers=3)

     # 构造参数列表
     params_list = list()
     per_thread_size = 30000000
     for i in range(math.ceil(file_size / per_thread_size)):
         byte_size = per_thread_size
         if i == math.ceil(file_size / per_thread_size) - 1:
             byte_size = file_size % per_thread_size
         start = i * per_thread_size + i
         params_list.append((start, byte_size))

     all_task = [executor.submit(copy, *params) for params in params_list]
     # 等待任务完成
     wait(all_task)
     if ws:
         ws.close()
     if rs:
         rs.close()

 if __name__ == '__main__':
     main()