Python多线程分片下载远端大文件 - threading paramiko

已于 2023-06-29 15:29:42 修改
阅读量800 收藏
点赞数
分类专栏： 随笔 文章标签： python 开发语言 pycharm
于 2023-06-29 15:16:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/holyvslin/article/details/131456792
版权
该代码示例展示了如何使用Python的paramiko库通过SSH和SFTP协议实现多线程分片下载远程大文件。通过获取CPU核心数并创建相应数量的线程，实现并发下载，提高下载效率。每个线程负责下载文件的一个分片，最后合并成完整的文件。
摘要由CSDN通过智能技术生成

Python多xian程分片下载远端大文件 ，可以按照以下流程设计代码框架：

  1.  导入需要的模块：首先，导入所需的模块，包括paramiko、os、time和threading。
  2.  创建下载函数：创建一个用于分片下载文件的函数。该函数将使用SSH连接到远程服务器，并使用SFTP协议下载文件的指定分片到本地路径。使用sftp_file.seek() 和 file.seek() 确保正确的块被下载
  3.  主函数：在主函数中，您需要设置远程服务器的主机名、用户名、密码、远程文件路径和本地存储路径。还需要确定要划分的分片数量。我们使用os.cpu_count()获取当前系统的CPU数量，并将文件分割成块，即多线程的数量为，2倍CPU个数以获取最大性能。我们创建一个Thread实例，每个实例负责一个文件块的下载。我们再次使用thread.join()等待所有进程完成，在完成后输出一条完成信息。
  4.  运行主函数：在主函数中，我们创建了一个进程池，并使用Threading方法来并发地调用分片下载函数。通过确定每个xian程所负责的起始字节和结束字节，从而实现对服务器端文件的分片下载。然后，我们关闭并等待进程池中的所有任务完成。

Python多线程分片下载远端大文件源码（多线程单独封装函数）：

import paramiko
import threading
import time
import os

def get_remote_file_size(ssh_info, remote_path):
    ssh = paramiko.SSHClient()
    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    ssh.connect(**ssh_info)
    sftp = ssh.open_sftp()
    # get remote file size
    remote_file_size = sftp.stat(remote_path).st_size
    print ("remote_file_size:{}".format(remote_file_size))
    sftp.close()
    ssh.close()
    return remote_file_size

def download_chunk_file(ssh_info, remote_path, local_path, start_pos, end_pos):
    print("download_chunk_file start")
    client = paramiko.SSHClient()
    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
    client.connect(**ssh_info)

    sftp = client.open_sftp()
    # open both local and remote file
    local_file = open(local_path, "r+b")
    remote_file = sftp.open(remote_path, "rb")

    # right shift to same start position
    local_file.seek(start_pos)
    remote_file.seek(start_pos)

    # print("start_pos ~ end_pos: {} ~ {}".format(start_pos, end_pos))
    while True:
        # read chunk file from remote file
        read_start = time.time()
        buffer = remote_file.read(end_pos - start_pos)
        if not buffer:
            break
        else:
            print("read  cost time {:.2f}s".format(time.time() - read_start))
        # write chunk file to local file
        write_start = time.time()
        local_file.write(buffer)
        print("write cost time {:.2f}s".format(time.time() - write_start))
    print("chunk file with start_pos ~ end_pos: {} ~ {}, Download successfully!".format(start_pos, end_pos))
    remote_file.close()
    local_file.close()
    client.close()
    print("download_chunk_file end")

def download_multithreading(ssh_info, remote_path, local_path):
    # get number of CPU with high efficiency
    # double the number of CPU cores for optimal performance
    num_threads = os.cpu_count() * 2
    #num_threads = 1
    print("number of CPU is {}, number of thread is {}".format(os.cpu_count(),num_threads))
    # get remote file size
    file_size = get_remote_file_size(ssh_info, remote_path)
    # create new empty local file, same size with remote file
    with open(local_path, "wb") as f:
        f.truncate(file_size)

    # calculate the chunk size, n-1 threading handle each chunk size sub-file, and last threading handle last remaining sub-file
    chunk_size = file_size // num_threads
    print("chunk_size is {}".format(chunk_size))
    # create number of thread
    threads = []
    # create a thread for each chunk
    for index in range(num_threads):
        #print("thread: {}".format(index))
        start_pos = index * chunk_size
        end_pos = start_pos + chunk_size
        # last thread will download the remaining bytes
        if index == num_threads - 1:
            end_pos = file_size - 1

        args = (ssh_info, remote_path, local_path, start_pos, end_pos)
        thread = threading.Thread(target=download_chunk_file, args=args)

        thread.start()
        print(thread)
        threads.append(thread)

    # wait for all the threads to finish
    for thread in threads:
        thread.join()
        print(thread)

def main():
    host = "host"
    port = 22
    username = "username"
    password = "password"
 
    remote_path = '/remote_dir/remote_file'
    local_path = '/local_dir/local_file'

    ssh_info = {
        "hostname": host,
        "port": port,
        "username": username,
        "password": password,
    }



    multithread_download_start = time.time()
    download_multithreading(ssh_info, remote_path, local_path)
    multithread_download_end = time.time()
    multithread_download_cost = multithread_download_end - multithread_download_start
    print("Full file Download successfully! Cost time: {:.2f}s".format(multithread_download_cost))


if __name__ == "__main__":
    main()

运行结果输出：

$ python multi_thread_download_single_bigfile_def.py
number of CPU is 4, number of thread is 8
remote_file_size:63376366
chunk_size is 7922045
download_chunk_file start
<Thread(Thread-3, started 139896856663808)>
download_chunk_file start
<Thread(Thread-4, started 139896848271104)>
download_chunk_file start
<Thread(Thread-6, started 139896831223552)>
download_chunk_file start
<Thread(Thread-7, started 139896614287104)>
download_chunk_file start
<Thread(Thread-9, started 139896597501696)>
download_chunk_file start
<Thread(Thread-12, started 139896572323584)>
download_chunk_file start
<Thread(Thread-14, started 139896010307328)>
download_chunk_file start
<Thread(Thread-16, started 139895993521920)>
read  cost time 3.84s
write cost time 0.01s
read  cost time 3.94s
read  cost time 4.00s
write cost time 0.02s
write cost time 0.02s
read  cost time 3.88s
write cost time 0.01s
read  cost time 3.96s
write cost time 0.01s
read  cost time 4.01s
read  cost time 4.00s
write cost time 0.01s
write cost time 0.02s
read  cost time 4.29s
write cost time 0.01s
read  cost time 0.01s
write cost time 0.00s
chunk file with start_pos ~ end_pos: 55454315 ~ 63376365, Download successfully!
download_chunk_file end
read  cost time 2.95s
write cost time 0.01s
read  cost time 2.94s
write cost time 0.00s
read  cost time 3.11s
write cost time 0.01s
read  cost time 3.06s
write cost time 0.01s
read  cost time 3.10s
write cost time 0.01s
read  cost time 3.07s
write cost time 0.00s
read  cost time 3.07s
write cost time 0.01s
read  cost time 0.01s
write cost time 0.00s
chunk file with start_pos ~ end_pos: 47532270 ~ 55454315, Download successfully!
download_chunk_file end
read  cost time 2.50s
write cost time 0.00s
read  cost time 2.67s
read  cost time 2.61s
write cost time 0.01s
write cost time 0.00s
read  cost time 0.04s
write cost time 0.00s
chunk file with start_pos ~ end_pos: 39610225 ~ 47532270, Download successfully!
download_chunk_file end
read  cost time 2.58s
write cost time 0.00s
read  cost time 2.64s
write cost time 0.00s
read  cost time 2.57s
write cost time 0.00s
read  cost time 2.30s
write cost time 0.01s
read  cost time 2.39s
write cost time 0.00s
read  cost time 0.00s
write cost time 0.00s
chunk file with start_pos ~ end_pos: 31688180 ~ 39610225, Download successfully!
download_chunk_file end
read  cost time 2.28s
write cost time 0.00s
read  cost time 2.29s
write cost time 0.00s
read  cost time 2.37s
write cost time 0.00s
read  cost time 2.20s
write cost time 0.00s
read  cost time 0.00s
write cost time 0.00s
chunk file with start_pos ~ end_pos: 23766135 ~ 31688180, Download successfully!
download_chunk_file end
read  cost time 2.18s
write cost time 0.00s
read  cost time 2.18s
write cost time 0.00s
read  cost time 2.30s
write cost time 0.00s
read  cost time 2.18s
write cost time 0.02s
read  cost time 2.13s
write cost time 0.00s
read  cost time 0.04s
write cost time 0.00s
chunk file with start_pos ~ end_pos: 15844090 ~ 23766135, Download successfully!
download_chunk_file end
read  cost time 2.24s
write cost time 0.00s
read  cost time 2.05s
write cost time 0.00s
read  cost time 2.06s
read  cost time 2.07s
write cost time 6.32s
read  cost time 0.00s
write cost time 0.00s
write cost time 4.46s
chunk file with start_pos ~ end_pos: 7922045 ~ 15844090, Download successfully!
read  cost time 0.00s
write cost time 0.00s
download_chunk_file end
chunk file with start_pos ~ end_pos: 0 ~ 7922045, Download successfully!
download_chunk_file end
<Thread(Thread-3, stopped 139896856663808)>
<Thread(Thread-4, stopped 139896848271104)>
<Thread(Thread-6, stopped 139896831223552)>
<Thread(Thread-7, stopped 139896614287104)>
<Thread(Thread-9, stopped 139896597501696)>
<Thread(Thread-12, stopped 139896572323584)>
<Thread(Thread-14, stopped 139896010307328)>
<Thread(Thread-16, stopped 139895993521920)>
Full file Download successfully! Cost: 25.37s


 

Entropy-Go
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
对python多线程SSH登录并发脚本详解
01-01
于是用多线程进行python并发记录 因为需要安装的一些依赖和模块比较麻烦，脚本完成后再用pyinstaller打成exe包分发给其他测试人员一起使用。 1.脚本编写 # -*- coding: utf-8 -*- import paramiko import threading...
Python 下载大文件速度更快的方式
Trb201013的博客
01-18 1371
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。这将文件流式传输到磁盘而不使用过多的内存，并且代码更简单。
Python多进程分片下载远端大文件 - multiprocessing paramiko
06-28 828
【代码】Python multiprocessing paramiko。
python异步下载超大文件
最新发布
2401_85969294的博客
07-06 323
大家好，小编在这里要分享，python下载大文件mp4 python下载速度太慢，现在让我们一起来看看吧！
Python：教你如何实现多线程下载器
有意栽花花不发，无心插柳柳成荫。
04-10 6723
Python 实现多线程下载器
Python最佳实践—requests模块下载超大文件，并实时显示下载进度和速度
魏德曼的博客
12-02 3322
Python最佳实践—requests模块下载超大文件，并实时显示下载进度和速度
Python 下载大文件，哪种方式速度更快
m0_72557783的博客
08-17 1059
通常，我们都会用 requests 库去下载，这个库用起来太方便了。
【Python】使用requests库实现多线程下载大文件
冰冷的希望的博客
11-25 3919
1.当我们请求下载文件的时候，可以使用head请求看一下该文件有多大，响应头里的“Content-Length”字段表示文件的字节数。使用使用requests库可以实现网络请求，但如果用于下载大文件，单线程下载确实不能很好地利用宽度，改为多线程会更好一点。2.拿到了文件大小之后，根据线程数划分为多个数据块，即每个线程都请求一部分，在请求头的“Range”字段指定下载范围。5.如果发现其中一个块下载失败了，那就相当于整个文件都失败了，不过我还是希望再尝试下载2次才确定失败。
python实现多线程的方式及多条命令并发执行
12-24
Thread 是threading模块中最重要的类之一，可以使用它来创建线程。有两种方式来创建线程：一种是通过继承Thread类，重写它的run方法；另一种是创建一个threading.Thread对象，在它的初始化函数（__init__）中将可...
python的paramiko模块实现远程控制和传输示例
09-21
若要在多台服务器上批量执行命令，可以结合Paramiko和多线程。下面的代码创建了一个线程函数`ssh_cmd`，然后启动一个线程执行命令： ```python import paramiko import threading def ssh_cmd(ip, port, username...
Python-python自动化运维技术与最佳实践书中示例及案例
08-10
4. **进程与线程**：Python的multiprocessing和threading模块使得并发执行任务成为可能，这对于多任务并行处理和提高效率至关重要。 5. **自动化工具**：如使用paramiko进行SSH连接，pexpect用于进程期望，fabric...
python文件传输demo
03-27
对于大文件传输，可以使用多线程或多进程来并行处理，提高传输效率。Python的`threading`和`multiprocessing`模块提供了相应功能。 10. **进度条显示**： 在传输大文件时，为用户提供进度反馈是非常友好的。可以...
Python-一个安全工具用于抓取许多网络主机的截图
08-10
4. **多线程或多进程**：由于可能需要同时处理多个主机，因此使用threading或multiprocessing库可以提高效率。 5. **异步IO（asyncio）**：Python的异步编程框架，可以在等待I/O操作（如网络请求）时执行其他任务，...
Python面试大全.pdf
06-19
本文详细介绍了 Python 面试中常见的一些基础知识和技术点，包括但不限于列表推导式、*args 和 **kwargs、装饰器、生成器、面向对象编程、异常处理、文件操作、模块和包、多线程和多进程、网络编程和数据库操作等...
Python-169912.zip
09-15
11. **并发编程**：Python的threading和multiprocessing模块支持多线程和多进程，asyncio库提供异步I/O，适用于高并发场景。 12. **版本控制**：Python项目通常使用Git进行版本控制，它可以帮助团队协作和管理代码...
RDE_Python
02-13
6. **多线程与并发**: 在处理多个远程连接时，Python的多线程或多进程特性（如`threading`或`multiprocessing`模块）可以提高效率。 7. **日志与错误处理**: 为了确保稳定运行，良好的日志记录（如使用`logging`...
从0到1手把手教你实现一个 Python 多线程下载器
涛哥聊Python
05-15 1053
本文是来自读者Sheep投稿https://zhuanlan.zhihu.com/p/369531344前言下载文件是我们生活中的一个常见的需求，因此衍生的下载工具也非常多，各有各的优势以...
python 下载大文件，断点续传 ｜ Python工具类
热门推荐
阿良的博客
10-24 4万+
目录 前言 依赖 工具代码 总结 前言 实用python进行大文件下载的时候，一旦出现网络波动问题，导致文件下载到一半。如果将下载不完全的文件删掉，那么又需要从头开始，如果连续网络波动，是不是要头秃了。本文提供断点续传下载工具方法，希望可以帮助到你。 依赖 os、sys、requests 工具代码 废话不多说，上代码。 #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sat Oct 23 13
python利用线程池多线程下载ts并合并
m0_59522760的博客
04-30 1328
需要通过插件把视频的m3u8文件移动过来。注意这边通过插件获得的m3u8文件是一行一行的ts文件的下载地址所以直接用。ts文件是一段一段的切片视频我们需要把他们下载好用ffmpeg合并，这样合并的视频比直接拼接的视频流畅没那么卡顿。这个插件可以直接提取m3u8文件省去判断的步骤。文件目录可以自己改，主要是用了个视频下载插件。对于加密的ts文件，这个程序并没有完善。concat.mp4就是生成的视频。
使用python语言基于面向对象思想利用paramiko远程进服务器，使用多线程批量ping并声音报警
04-24
您的问题是如何使用Python语言基于面向对象思想利用Paramiko远程进服务器，使用多线程批量ping并声音报警。 首先，您可以使用Paramiko库来建立一个SSH连接。下面是一些样例代码： ```python import paramiko import sys class SSH: def __init__(self, hostname, username, password): self._ssh = paramiko.SSHClient() self._ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) self._ssh.connect(hostname, username = username, password = password) def execute(self, command): stdin, stdout, stderr = self._ssh.exec_command(command) if stderr.read(): print("Failed to run command: " + command) return None return stdout.readlines() #测试 ssh = SSH('localhost', 'user', 'password') output = ssh.execute("ls -l") print(output) ``` 其中，`SSH`类的构造函数通过`paramiko`库连接到指定主机，并提供用户名和密码。`execute`方法执行给定的命令并返回输出。测试代码展示了如何创建`SSH`对象并执行简单的命令。 接下来，您可以使用多线程来批量ping主机。下面是一些样例代码： ```python import threading import subprocess import re class Ping(threading.Thread): def __init__(self, ip): threading.Thread.__init__(self) self.ip = ip self.status = None def run(self): ping_output = subprocess.Popen(['ping', '-c', '1', self.ip], stdout = subprocess.PIPE).communicate()[0] self.status = re.findall("100% packet loss", ping_output.decode('utf-8')) #测试 threads = [] iplist = ['127.0.0.1', '127.0.0.2'] for ip in iplist: thread = Ping(ip) thread.start() threads.append(thread) for thread in threads: thread.join() if thread.status: print(ip + "is down!") else: print(ip + "is up!") ``` 以上简单地演示了如何使用多线程ping某些IP，并查看是否有失去任何数据包。如果某个IP无法到达，程序会输出警告。 最后，您可以使用Python库来播放声音。下面是一些参考代码： ```python import pygame class Sound: def __init__(self, filename): pygame.mixer.init() pygame.mixer.music.load(filename) def play(self): pygame.mixer.music.play() def stop(self): pygame.mixer.music.stop() #测试 sound = Sound('/path/to/your/sound/file.mp3') sound.play() ``` 在以上代码中，`Sound`类使用pygame库初始化音乐播放器。`play`方法播放指定的音频文件。测试代码展示了如何创建`Sound`对象并播放音频文件。 这样，您可以将上述三个组件组合在一起，以实现对大量主机的远程监控以及警报，即在向所有目标ping命令的同时，使用多线程执行该过程，并在服务器未响应时发送警报声音。 希望对您有所帮助！
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值