Comment implémenter des téléchargements de fichiers hautement simultanés dans Swoole

Avec le développement rapide d'Internet et l'avènement de l'ère du big data, les applications à haute concurrence deviennent de plus en plus courantes, et le téléchargement de fichiers ne fait pas exception. La mise en œuvre de téléchargements de fichiers hautement simultanés dans Swoole présente plus d'avantages que les méthodes traditionnelles.

Swoole est un moteur de communication réseau coroutine haute performance dans le langage PHP. Il peut fournir des fonctionnalités avancées telles que les coroutines, les E/S asynchrones et le multi-processus en PHP. Il prend en charge plusieurs protocoles tels que HTTP/WebSocket/TCP/UDP, et convient au développement Web, aux serveurs de jeux, à l'Internet des objets, aux communications en temps réel et à d'autres domaines. Ensuite, nous utiliserons Swoole pour réaliser un téléchargement de fichiers à haute concurrence.

Étape 1 : Installez l'extension Swoole

Tout d'abord, nous devons installer l'extension Swoole. Vous pouvez l'installer selon la documentation officielle, ou vous pouvez l'installer via Composer, l'outil de gestion de packages PHP. Ici, nous l'installons via Composer.

Entrez la commande suivante dans le terminal pour installer :

composer require swoole/swoole

Étape 2 : Écrivez le code pour télécharger le fichier

Ensuite, nous commençons à écrire le code pour télécharger le fichier. Nous pouvons télécharger via le client HTTP asynchrone fourni par Swoole.

$http = new SwooleCoroutineHttpClient('www.example.com', 80);
$http->setHeaders([
    'Host'            => 'www.example.com',
    'User-Agent'      => 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36',
    'Accept'          => 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
    'Accept-Encoding' => 'gzip, deflate, sdch',
    'Accept-Language' => 'zh-CN,zh;q=0.8,en;q=0.6',
]);

$http->download('/path/to/localfile', '/remote/path/to/file');

Dans le code ci-dessus, nous instancions un client HTTP asynchrone et définissons certains paramètres de la requête, tels que les informations d'en-tête de la requête, etc. Appelez ensuite la méthode de téléchargement pour télécharger le fichier. Parmi eux, le premier paramètre est le chemin du fichier local et le deuxième paramètre est le chemin distant du fichier à télécharger.

Étape 3 : Encapsuler le code dans une méthode réutilisable

Le code ci-dessus ne peut effectuer qu'un seul téléchargement de fichier. Si un grand nombre de téléchargements sont nécessaires, le code doit être encapsulé dans une méthode réutilisable. Dans la méthode, nous pouvons utiliser des coroutines pour implémenter un traitement de téléchargement simultané multitâche, comme suit :

function batchDownload($uris, $outputDir, $concurrency = 64)
{
    $n = count($uris);
    $running = true;
    $workers = [];
    for ($i = 0; $i < $concurrency; $i++) {
        $co = run(function () use ($outputDir, &$running, &$workers) {
            $client = new SwooleCoroutineHttpClient('www.example.com', 80);
            while ($running || !empty($workers)) {
                if (!empty($workers)) {
                    $url = array_shift($workers);
                    $client->download("{$outputDir}/".basename($url), $url);
                } else {
                    Coroutine::sleep(0.1);
                }
            }
        });
        $workers[] = null;
    }
    foreach ($uris as $url) {
        $workers[] = $url;
    }
    $running = false;
    //所有协程结束后回收资源
    for ($i = 0; $i < $concurrency; $i++) {
        $co = array_shift($workers);
        $co->join();
    }
}

Dans le code ci-dessus, nous avons créé des coroutines $concurrency pour un traitement asynchrone via une boucle for, et chaque coroutine est une requête indépendante, après En traitant une demande, la demande suivante sera automatiquement traitée, atteignant ainsi l'objectif de traiter plusieurs demandes simultanément.

De même, le code ci-dessus peut télécharger des fichiers par lots en appelant la méthode batchDownload, comme suit :

$uris = ['https://www.example.com/image1.jpg', 'https://www.example.com/image2.jpg', 'https://www.example.com/image3.jpg'];
$outputDir = '/path/to/output';
batchDownload($uris, $outputDir);

Résumé

L'implémentation de téléchargements de fichiers à haute concurrence dans Swoole est meilleure que la méthode traditionnelle, et les E/S asynchrones sont implémentées via des coroutines. La commutation entre le processeur et les E/S élimine le besoin d'attendre la réponse du serveur, ce qui améliore considérablement les capacités de traitement simultané des requêtes. Dans le même temps, il est pratique et rapide d'encapsuler le code dans une méthode réutilisable, afin que nous puissions l'appeler directement lors du développement ultérieur, améliorant ainsi l'efficacité du développement.

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!