Asynchrone PHP-Coroutine-Entwicklung: Lösung des Problems des Hoch- und Herunterladens großer Dateien

Mit der Entwicklung der Netzwerktechnologie und der kontinuierlichen Erweiterung der Anwendungsszenarien ist das Hoch- und Herunterladen großer Dateien für viele Webanwendungen zu einem Problem geworden. Herkömmliche Verarbeitungsmethoden sind oft zeitaufwändig und wenig effizient, und die asynchrone Coroutine-Entwicklung mit PHP kann diese Probleme effektiv lösen.

In den letzten Jahren wurde die asynchrone Programmiertechnologie der PHP-Sprache nach und nach weit verbreitet, wobei die Coroutine-Technologie in der tatsächlichen Entwicklung immer häufiger eingesetzt wurde. Eine Coroutine ist eine erweiterte Form des Benutzer-Threadings, die es einem Thread ermöglicht, die Ausführung des Threads zu unterbrechen, auf das Eintreten eines Ereignisses zu warten und dann fortzusetzen. Laienhaft ausgedrückt bedeutet dies, dass die CPU während der Codeausführung aktiv für andere Vorgänge freigegeben wird.

Die Anwendung der asynchronen PHP-Coroutine-Entwicklung beim Hoch- und Herunterladen großer Dateien wird im Folgenden ausführlich vorgestellt.

1. Hochladen großer Dateien

In Webanwendungen werden große Datei-Uploads im Allgemeinen über das HTTP-Protokoll implementiert. Wenn ein Benutzer eine große Datei hochlädt, muss der Server die Datei in den Speicher einlesen und auf die Festplatte schreiben. Dieser Vorgang nimmt viel Zeit und Ressourcen in Anspruch. Wenn bei der herkömmlichen Verarbeitungsmethode eine große Datei hochgeladen wird, wartet der Server auf den Abschluss des Uploads und kann keine anderen Anforderungen gleichzeitig verarbeiten. Dies verschwendet nicht nur Ressourcen, sondern beeinträchtigt auch die Benutzererfahrung.

Lösung basierend auf Coroutine:

1. Der Client lädt die Datei in Slices auf den Server hoch. Dies wird mithilfe der FormData-API und des XMLHttpRequest-Objekts implementiert. 2. Nachdem der Server die Upload-Anfrage erhalten hat, überprüft er die Anzahl der Slices Stimmt die hochgeladene Datei mit der Dateigröße überein? Wenn ja, speichern Sie die empfangenen Slices in der Zieldatei.

3. Wenn sie inkonsistent sind, wird eine Fehlermeldung zurückgegeben. Wenn ein Dateiblock nicht empfangen werden kann, sollten andere hochgeladene Blöcke bereinigt werden, um zu vermeiden, dass halbfertige Dateien erstellt werden.

4. Nachdem der Upload abgeschlossen ist, kann der Server die Dateiattribute usw. bearbeiten. Wenn die Datei relativ groß ist, kann sie asynchron verarbeitet werden, um eine IO- und CPU-intensive Empfindlichkeit gegenüber der CPU zu vermeiden.

Das Folgende ist ein Beispielcode:

<?php
// 启用协程运行时
SwooleRuntime::enableCoroutine();

$http = new SwooleHttpServer("127.0.0.1", 9501);

// 监听HTTP请求
$http->on("request", function ($request, $response) {

    // 从请求中获取分块数据
    $chunk = $request->rawContent();

    // 获取分块所属的文件名和分块编号
    $fileName = $_POST['fileName'];
    $chunkIndex = $_POST['chunkIndex'];

    // 将分块数据追加写入到目标文件中
    $fp = fopen($fileName, 'ab');
    fwrite($fp, $chunk);
    fclose($fp);

    // 判断是否上传完成
    if (intval($_POST['totalChunks']) == $chunkIndex + 1) {
        $response->end("Upload completed.");
    } else {
        $response->end("Upload success.");
    }
});

$http->start();

2. Download großer Dateien

In Webanwendungen werden große Dateidownloads auch über das HTTP-Protokoll implementiert. Wenn ein Benutzer eine große Datei herunterladen muss, muss der Server die Datei von der Festplatte lesen und an den Client senden. Dieser Vorgang nimmt ebenfalls viel Zeit und Ressourcen in Anspruch. Wenn der Server bei der herkömmlichen Verarbeitungsmethode die gesamte Datei auf einmal in den Speicher einliest und an den Client sendet, verschwendet dies nicht nur Ressourcen, sondern kann auch zum Absturz des Servers führen.

Coroutine-basierte Lösung:

Erstens jedes Mal einen bestimmten Datenblock von der Festplatte lesen und an den Client senden

Zweitens Coroutine zur Steuerung verwenden und nach jeder bestimmten Datenmenge die CPU aufgeben wird gesendet

3. Nachdem der Client den aktuellen Block verbraucht hat, sendet er eine Nachricht an den Server und gibt die Datenübertragung des nächsten Blocks ein

Das Folgende ist ein Beispielcode:

<?php
// 启用协程运行时
SwooleRuntime::enableCoroutine();

$server = new SwooleHttpServer('127.0.0.1', 9502);

$server->on('request', function($request, $response) {
    $filePath = '/path/to/large/file';
    $startPos = 0;
    $readChunkSize = 8192;

    $fileSize = filesize($filePath);

    $response->header('Content-Type', 'application/octet-stream');
    $response->header('Accept-Ranges', 'bytes');

    // 读取和发送一块数据
    function readAndSendChunk($fp, $response, $startPos, $readChunkSize, $fileSize) {
        fseek($fp, $startPos);
        $maxLength = $fileSize - $startPos;
        if ($maxLength > $readChunkSize) {
            $maxLength = $readChunkSize;
        }
        $data = fread($fp, $maxLength);
        $response->write($data);
        return $startPos + $maxLength;
    }

    // 每发送一定量的数据后yield，让出CPU
    function sendByYield($fp, $response, $startPos, $readChunkSize, $fileSize) {
        while ($startPos < $fileSize) {
            $startPos = readAndSendChunk($fp, $response, $startPos, $readChunkSize, $fileSize);
            yield;
        }
        fclose($fp);
        $response->end();
    }

    // 检查是否支持断点续传
    $range = $request->header['range'];
    if ($range) {
        $status = '206 Partial Content';
        $range = explode('-', substr($range, 6));
        if ($range[0] === '') {
            $startPos = $fileSize - intval($range[1]);
        } else if ($range[1] === '') {
            $startPos = intval($range[0]);
        } else {
            $startPos = intval($range[0]);
            $readChunkSize = intval($range[1]) - $startPos + 1;
            $response->header('Content-Length', $readChunkSize);
        }
    } else {
        $status = '200 OK';
        $response->header('Content-Length', $fileSize);
    }

    $response->header('HTTP/1.1', $status);
    $response->header('Content-Disposition', 'attachment;filename="'.basename($filePath).'"');
    $response->header('Content-Range', 'bytes '.$startPos.'-'.($startPos+$readChunkSize-1).'/'.$fileSize);

    $fp = fopen($filePath, 'rb');
    fseek($fp, $startPos);

    $response->status(200);

    // 使用协程进行控制
    for ($i = 1; $i <= 5; $i++) {
        go(function() use ($fp, $response, $startPos, $readChunkSize, $fileSize) {
            yield from sendByYield($fp, $response, $startPos, $readChunkSize, $fileSize);
        });
    }
});

$server->start();

Fazit:

Dieser Artikel stellt asynchrone PHP-Coroutinen im Detail vor. Entwickeln Sie Anwendungen zum Hoch- und Herunterladen großer Dateien und stellen Sie spezifische Code-Implementierungsbeispiele bereit. In der tatsächlichen Entwicklung kann der Einsatz von Coroutine-basierter asynchroner Programmiertechnologie die Verarbeitungsleistung und das Benutzererlebnis von Webanwendungen effektiv verbessern, was einer eingehenden Forschung und Erkundung durch Entwickler würdig ist.

Das obige ist der detaillierte Inhalt vonAsynchrone PHP-Coroutine-Entwicklung: Lösung des Problems des Hoch- und Herunterladens großer Dateien. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!