Asynchrone Coroutine-Entwicklungspraxis: Optimierung der Geschwindigkeit beim Hoch- und Herunterladen großer Dateien

Asynchrone Coroutine-Entwicklungspraxis: Optimierung der Geschwindigkeit beim Hoch- und Herunterladen großer Dateien

Mit der Entwicklung und Popularisierung des Internets ist die Dateiübertragung zur Norm geworden. Wenn die übertragenen Dateien jedoch immer größer werden, stoßen herkömmliche Methoden zum Hoch- und Herunterladen von Dateien auf viele Schwierigkeiten. Um die Übertragungsgeschwindigkeit großer Dateien zu optimieren und die Benutzererfahrung zu verbessern, können wir dies durch asynchrone Coroutinen implementieren. In diesem Artikel erfahren Sie, wie Sie mithilfe der asynchronen Coroutine-Technologie die Upload- und Download-Geschwindigkeit großer Dateien optimieren können, und stellen spezifische Codebeispiele bereit.

1. Einführung in die asynchrone Coroutine-Technologie

Asynchrone Coroutine ist im Wesentlichen ein Programmiermodell. Seine Besonderheit besteht darin, dass er beim Auftreten einer Blockierung sofort die Kontrolle über den aktuellen Thread freigeben, die Kontrolle an andere Aufgaben übergeben kann, um die Ausführung fortzusetzen, und warten kann, bis die Blockierung beendet ist, bevor er zur Ausführung zurückkehrt, wodurch ein Wechsel zwischen mehreren Aufgaben realisiert wird, um bessere Ergebnisse zu erzielen . Effizienter Verarbeitungseffekt.

Zu den gängigen asynchronen Coroutine-Technologien gehören Asyncio in Python, Callback und Promise in Node.js usw. Unterschiedliche Sprachen und Technologien verfügen möglicherweise über unterschiedliche Implementierungsmethoden, sind jedoch im Wesentlichen alle darauf ausgelegt, Computerressourcen besser zu nutzen, um die Parallelität und Verarbeitungseffizienz zu verbessern.

2. Optimieren Sie die Geschwindigkeit beim Hochladen großer Dateien

1. Bei Verwendung von Chunk-Uploads

Beim Hochladen großer Dateien führt die Übertragung der gesamten Datei auf einmal auf den Server unweigerlich zu einer Netzwerküberlastung und langsamen Übertragungsgeschwindigkeiten. Um dieses Problem zu vermeiden, können große Dateien in mehrere Blöcke hochgeladen werden. Jeder Block ist ein unabhängiges Datenpaket und kann parallel hochgeladen werden, um den Upload zu beschleunigen.

Mithilfe der asynchronen Coroutine-Technologie können Sie problemlos Chunk-Uploads implementieren und mehrere Datenblöcke parallel übertragen, um effizientere Upload-Vorgänge zu erzielen. Das Folgende ist die spezifische Code-Implementierung.

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())

In diesem Code teilen wir die gesamte Datei in 5-MB-Datenblöcke auf und verwenden dann die Methode asyncio.gather(), um die Aufgaben des Hochladens jedes Datenblocks gleichzeitig auszuführen, um den Upload zu beschleunigen. Geschwindigkeit. Die Idee des gebündelten Hochladens gilt auch für das Herunterladen von Dateien. Weitere Informationen finden Sie im nächsten Abschnitt. 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

Multithread-Upload

Zusätzlich zum Chunk-Upload können Sie auch Multithreading zum Hochladen großer Dateien verwenden. Durch die Verwendung von Multithreading können Sie die Multi-Core-Ressourcen Ihres Computers besser nutzen und so das Hochladen von Dateien beschleunigen. Das Folgende ist die spezifische Code-Implementierung.

rrreee🎜In diesem Code verwenden wir das Modul threading in der Python-Standardbibliothek, um den Multithread-Upload zu implementieren. Teilen Sie die gesamte Datei in mehrere Datenblöcke auf, und jeder Thread ist dafür verantwortlich, einen davon hochzuladen, wodurch gleichzeitige Uploads erreicht werden. Verwenden Sie einen Sperrmechanismus, um die Thread-Sicherheit bei gleichzeitigen Uploads zu schützen. 🎜🎜3. Optimieren Sie die Geschwindigkeit beim Herunterladen großer Dateien🎜🎜Neben dem Hochladen ist auch das Herunterladen großer Dateien eine sehr häufige Anforderung, und die Optimierung kann auch durch asynchrone Coroutinen erreicht werden. 🎜🎜🎜Massen-Download🎜🎜🎜Ähnlich wie der Chunked-Upload unterteilt der Chunked-Download die gesamte Datei in mehrere Chunks, jeder Chunk wird unabhängig heruntergeladen und mehrere Datenchunks werden parallel übertragen, um den Download zu beschleunigen. Die spezifische Code-Implementierung lautet wie folgt: 🎜rrreee🎜In diesem Code verwenden wir die aiohttp-Bibliothek, um parallele Downloads von asynchronen Coroutinen durchzuführen. Teilen Sie auf ähnliche Weise die gesamte Datei in 5-MB-Datenblöcke auf und verwenden Sie dann die Methode asyncio.gather(), um die Aufgaben zum Herunterladen jedes Datenblocks gleichzeitig auszuführen und so das Herunterladen der Datei zu beschleunigen. 🎜
🎜Multithread-Download🎜🎜🎜Zusätzlich zum Herunterladen in Blöcken können Sie auch Multithread-Downloads verwenden, um große Dateien herunterzuladen. Die spezifische Code-Implementierung lautet wie folgt: 🎜rrreee🎜In diesem Code verwenden wir auch das threading-Modul in der Python-Standardbibliothek, um Multithread-Downloads zu implementieren. Die gesamte Datei ist in mehrere Datenblöcke unterteilt, und jeder Thread ist für das Herunterladen eines der Blöcke verantwortlich, wodurch ein gleichzeitiges Herunterladen erreicht wird. Der Sperrmechanismus wird auch zum Schutz der Thread-Sicherheit bei gleichzeitigen Downloads verwendet. 🎜🎜4. Zusammenfassung🎜🎜In diesem Artikel wird erläutert, wie Sie mit der asynchronen Coroutine-Technologie die Upload- und Download-Geschwindigkeit großer Dateien optimieren können. Durch Blockierung und Parallelverarbeitung bei Upload- und Download-Vorgängen kann die Effizienz der Dateiübertragung schnell verbessert werden. Ob in asynchronen Coroutinen, Multithreading, verteilten Systemen und anderen Bereichen, es gibt ein breites Anwendungsspektrum. Ich hoffe, dieser Artikel hilft Ihnen! 🎜

Das obige ist der detaillierte Inhalt vonAsynchrone Coroutine-Entwicklungspraxis: Optimierung der Geschwindigkeit beim Hoch- und Herunterladen großer Dateien. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!