Pratique de développement de coroutine asynchrone : optimisation de la vitesse de téléchargement et de téléchargement de fichiers volumineux

Pratique de développement de coroutines asynchrones : optimiser la vitesse de téléchargement et de téléchargement de fichiers volumineux

Avec le développement et la popularisation d'Internet, la transmission de fichiers est devenue la norme. Mais lorsque les fichiers transférés deviennent de plus en plus volumineux, les méthodes traditionnelles de téléchargement et de téléchargement de fichiers rencontreront de nombreuses difficultés. Afin d'optimiser la vitesse de transmission des fichiers volumineux et d'améliorer l'expérience utilisateur, nous pouvons l'implémenter via des coroutines asynchrones. Cet article explique comment utiliser la technologie de coroutine asynchrone pour optimiser la vitesse de téléchargement de fichiers volumineux et fournit des exemples de code spécifiques.

1. Introduction à la technologie de la coroutine asynchrone

La coroutine asynchrone est essentiellement un modèle de programmation. Sa caractéristique est que lorsqu'un blocage se produit, il peut immédiatement libérer le contrôle du thread actuel, confier le contrôle à d'autres tâches pour continuer l'exécution et attendre la fin du blocage avant de revenir à l'exécution, réalisant ainsi la commutation entre plusieurs tâches pour réaliser meilleurs résultats. Effet de traitement efficace.

Les technologies de coroutine asynchrone courantes incluent asyncio en Python, Callback et Promise dans Node.js, etc. Différents langages et technologies peuvent avoir des méthodes de mise en œuvre différentes, mais elles sont essentiellement toutes conçues pour mieux utiliser les ressources informatiques afin d'améliorer la concurrence et l'efficacité du traitement.

2. Optimisez la vitesse des téléchargements de fichiers volumineux

1. Lors de l'utilisation du téléchargement fragmenté

Lors du téléchargement de fichiers volumineux, le transfert de l'intégralité du fichier vers le serveur en une seule fois entraînera inévitablement une congestion du réseau et des vitesses de transmission lentes. Pour éviter ce problème, les fichiers volumineux peuvent être téléchargés en plusieurs morceaux. Chaque morceau est un paquet de données indépendant et peut être téléchargé en parallèle pour accélérer le téléchargement.

Grâce à la technologie de coroutine asynchrone, vous pouvez facilement mettre en œuvre des téléchargements fragmentés et transmettre plusieurs morceaux de données en parallèle pour obtenir des opérations de téléchargement plus efficaces. Ce qui suit est l’implémentation spécifique du code.

import aiohttp
import asyncio

async def upload_chunk(session, url, file, offset, size):
    headers = {'Content-Length': str(size), 'Content-Range': f'bytes {offset}-{offset+size-1}/{file_size}'}
    data = file.read(size)
    async with session.put(url, headers=headers, data=data) as resp:
        return await resp.json()

async def upload_file_with_chunks(session, url, file):
    file_size = os.path.getsize(file.name)
    chunk_size = 1024 * 1024 * 5 #每块数据的大小为5MB
    offset = 0
    tasks = []
    while offset < file_size:
        size = chunk_size if offset+chunk_size < file_size else file_size-offset
        tasks.append(upload_chunk(session, url, file, offset, size))
        offset += size
    return await asyncio.gather(*tasks)

async def main():
    async with aiohttp.ClientSession() as session:
        url = 'http://example.com/upload'
        file = open('large_file.mp4', 'rb')
        result = await upload_file_with_chunks(session, url, file)
        print(result)

asyncio.run(main())

Dans ce code, nous divisons l'intégralité du fichier en blocs de données d'une taille de 5 Mo, puis utilisons la méthode asyncio.gather() pour exécuter simultanément les tâches de téléchargement de chaque bloc de données pour accélérer augmenter la vitesse de téléchargement. L'idée du téléchargement fragmenté s'applique également au téléchargement de fichiers. Veuillez consulter la section suivante pour plus de détails. asyncio.gather()方法将上传各个数据块的任务并发执行，以加快上传速度。分块上传的思路也同样适用于文件下载，具体请看下一节内容。

2. 多线程上传

除了使用分块上传，还可以使用多线程的方式来实现大文件的上传操作。使用多线程可以更充分地利用计算机的多核资源，从而加速文件上传的速度。下面是具体的代码实现。

import threading
import requests

class MultiPartUpload(object):
    def __init__(self, url, file_path, num_thread=4):
        self.url = url
        self.file_path = file_path
        self.num_thread = num_thread
        self.file_size = os.path.getsize(self.file_path)
        self.chunk_size = self.file_size//num_thread
        self.threads = []
        self.lock = threading.Lock()

    def upload(self, i):
        start = i * self.chunk_size
        end = start + self.chunk_size - 1
        headers = {"Content-Range": "bytes %s-%s/%s" % (start, end, self.file_size),
                   "Content-Length": str(self.chunk_size)}
        data = open(self.file_path, 'rb')
        data.seek(start)
        resp = requests.put(self.url, headers=headers, data=data.read(self.chunk_size))
        self.lock.acquire()
        print("Part %d status: %s" % (i, resp.status_code))
        self.lock.release()

    def run(self):
        for i in range(self.num_thread):
            t = threading.Thread(target=self.upload, args=(i,))
            self.threads.append(t)
        for t in self.threads:
            t.start()

        for t in self.threads:
            t.join()

if __name__ == '__main__':
    url = 'http://example.com/upload'
    file = 'large_file.mp4'
    uploader = MultiPartUpload(url, file)
    uploader.run()

在这段代码中，我们使用了Python标准库中的threading模块来实现多线程上传。将整个文件分成多个数据块，每个线程负责上传其中的一块，从而实现并发上传。使用锁机制来保护并发上传过程中的线程安全。

三、优化大文件下载的速度

除了上传，下载大文件同样是一个很常见的需求，同样可以通过异步协程来实现优化。

1. 分块下载

和分块上传类似，分块下载将整个文件划分成若干块，每一块独立下载，并行传输多个块数据，从而加快下载速度。具体的代码实现如下：

import aiohttp
import asyncio
import os

async def download_chunk(session, url, file, offset, size):
    headers = {'Range': f'bytes={offset}-{offset+size-1}'}
    async with session.get(url, headers=headers) as resp:
        data = await resp.read()
        file.seek(offset)
        file.write(data)
        return len(data)

async def download_file_with_chunks(session, url, file):
    async with session.head(url) as resp:
        file_size = int(resp.headers.get('Content-Length'))
        chunk_size = 1024 * 1024 * 5 #每块数据的大小为5MB
        offset = 0
        tasks = []
        while offset < file_size:
            size = chunk_size if offset+chunk_size < file_size else file_size-offset
            tasks.append(download_chunk(session, url, file, offset, size))
            offset += size
        return await asyncio.gather(*tasks)

async def main():
    async with aiohttp.ClientSession() as session:
        url = 'http://example.com/download/large_file.mp4'
        file = open('large_file.mp4', 'wb+')
        await download_file_with_chunks(session, url, file)

asyncio.run(main())

在这段代码中，我们使用了aiohttp库来进行异步协程的并行下载。同样地，将整个文件分成大小为5MB的数据块，然后使用asyncio.gather()方法将下载各个数据块的任务并发执行，加快文件下载速度。

2. 多线程下载

除了分块下载，还可以使用多线程下载的方式来实现大文件的下载操作。具体的代码实现如下：

import threading
import requests

class MultiPartDownload(object):
    def __init__(self, url, file_path, num_thread=4):
        self.url = url
        self.file_path = file_path
        self.num_thread = num_thread
        self.file_size = requests.get(self.url, stream=True).headers.get('Content-Length')
        self.chunk_size = int(self.file_size) // self.num_thread
        self.threads = []
        self.lock = threading.Lock()

    def download(self, i):
        start = i * self.chunk_size
        end = start + self.chunk_size - 1 if i != self.num_thread - 1 else ''
        headers = {"Range": "bytes=%s-%s" % (start, end)}
        data = requests.get(self.url, headers=headers, stream=True)
        with open(self.file_path, 'rb+') as f:
            f.seek(start)
            f.write(data.content)
        self.lock.acquire()
        print("Part %d Downloaded." % i)
        self.lock.release()

    def run(self):
        for i in range(self.num_thread):
            t = threading.Thread(target=self.download, args=(i,))
            self.threads.append(t)
        for t in self.threads:
            t.start()

        for t in self.threads:
            t.join()

if __name__ == '__main__':
    url = 'http://example.com/download/large_file.mp4'
    file = 'large_file.mp4'
    downloader = MultiPartDownload(url, file)
    downloader.run()

在这段代码中，我们同样使用了Python标准库中的threading

Téléchargement multithread

En plus d'utiliser le téléchargement fragmenté, vous pouvez également utiliser le multithread pour télécharger des fichiers volumineux. L'utilisation du multithreading peut permettre une utilisation plus complète des ressources multicœurs de votre ordinateur, accélérant ainsi le téléchargement de fichiers. Ce qui suit est l’implémentation spécifique du code.

rrreee🎜Dans ce code, nous utilisons le module threading de la bibliothèque standard Python pour implémenter le téléchargement multi-thread. Divisez l'intégralité du fichier en plusieurs blocs de données et chaque thread est responsable du téléchargement de l'un d'entre eux, réalisant ainsi des téléchargements simultanés. Utilisez un mécanisme de verrouillage pour protéger la sécurité des threads lors des téléchargements simultanés. 🎜🎜3. Optimiser la vitesse de téléchargement de fichiers volumineux🎜🎜En plus du téléchargement, le téléchargement de fichiers volumineux est également une exigence très courante, et l'optimisation peut également être réalisée grâce à des coroutines asynchrones. 🎜🎜🎜Téléchargement groupé🎜🎜🎜Semblable au téléchargement fragmenté, le téléchargement fragmenté divise l'intégralité du fichier en plusieurs morceaux, chaque morceau est téléchargé indépendamment et plusieurs morceaux de données sont transférés en parallèle pour accélérer le téléchargement. L'implémentation spécifique du code est la suivante : 🎜rrreee🎜Dans ce code, nous utilisons la bibliothèque aiohttp pour effectuer des téléchargements parallèles de coroutines asynchrones. De même, divisez l'intégralité du fichier en blocs de données de 5 Mo, puis utilisez la méthode asyncio.gather() pour exécuter simultanément les tâches de téléchargement de chaque bloc de données afin d'accélérer le téléchargement du fichier. 🎜
🎜Téléchargement multithread🎜🎜🎜En plus du téléchargement par morceaux, vous pouvez également utiliser le téléchargement multithread pour télécharger des fichiers volumineux. L'implémentation spécifique du code est la suivante : 🎜rrreee🎜Dans ce code, nous utilisons également le module threading de la bibliothèque standard Python pour implémenter le téléchargement multithread. L'ensemble du fichier est divisé en plusieurs blocs de données et chaque thread est responsable du téléchargement de l'un des blocs, réalisant ainsi un téléchargement simultané. Le mécanisme de verrouillage est également utilisé pour protéger la sécurité des threads lors de téléchargements simultanés. 🎜🎜4. Résumé🎜🎜Cet article explique comment utiliser la technologie de coroutine asynchrone pour optimiser la vitesse de téléchargement de fichiers volumineux. En bloquant et en traitant en parallèle les opérations de téléchargement et de téléchargement, l'efficacité du transfert de fichiers peut être rapidement améliorée. Que ce soit dans les coroutines asynchrones, le multi-threading, les systèmes distribués et d'autres domaines, il a un large éventail d'applications. J'espère que cet article vous aidera ! 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!