Partage pratique de l'utilisation de Swoole pour explorer des pages Web de manière asynchrone

Les programmeurs PHP savent tous que les programmes écrits en PHP sont tous synchrones. Comment écrire un programme asynchrone en PHP La réponse est Swoole. Ici, nous prenons l'analyse du contenu Web comme exemple pour montrer comment utiliser Swoole pour écrire des programmes asynchrones.

Programme de synchronisation PHP

Avant d'écrire un programme asynchrone, ne vous inquiétez pas, utilisez d'abord PHP pour implémenter le programme de synchronisation.

<?php
/**
 * Class Crawler
 * Path: /Sync/Crawler.php
 */
class Crawler
{
    private $url;
    private $toVisit = [];
    public function __construct($url)
    {
        $this->url = $url;
    }
    public function visitOneDegree()
    {
        $this->loadPageUrls();
        $this->visitAll();
    }
    private function loadPageUrls()
    {
        $content = $this->visit($this->url);
        $pattern = &#39;#((http|ftp)://(\S*?\.\S*?))([\s)\[\]{},;"\&#39;:<]|\.\s|$)#i&#39;;
        preg_match_all($pattern, $content, $matched);
        foreach ($matched[0] as $url) {
            if (in_array($url, $this->toVisit)) {
                continue;
            }
            $this->toVisit[] = $url;
        }
    }
    private function visitAll()
    {
        foreach ($this->toVisit as $url) {
            $this->visit($url);
        }
    }
    private function visit($url)
    {
        return @file_get_contents($url);
    }
}

<?php
/**
 * crawler.php
 */
require_once &#39;Sync/Crawler.php&#39;;
$start = microtime(true);
$url = &#39;http://www.swoole.com/&#39;;
$ins = new Crawler($url);
$ins->visitOneDegree();
$timeUsed = microtime(true) - $start;
echo "time used: " . $timeUsed;
/* output:
time used: 6.2610177993774
*/

Une étude préliminaire sur la mise en œuvre par Swoole des robots d'exploration asynchrones

Référez-vous d'abord à la page officielle d'exploration asynchrone.
Exemple d'utilisation

Swoole\Async::dnsLookup("www.baidu.com", function ($domainName, $ip) {
    $cli = new swoole_http_client($ip, 80);
    $cli->setHeaders([
        'Host' => $domainName,
        "User-Agent" => 'Chrome/49.0.2587.3',
        'Accept' => 'text/html,application/xhtml+xml,application/xml',
        'Accept-Encoding' => 'gzip',
    ]);
    $cli->get('/index.html', function ($cli) {
        echo "Length: " . strlen($cli->body) . "\n";
        echo $cli->body;
    });
});

Il semble qu'en modifiant légèrement le code synchrone file_get_contents, une implémentation asynchrone puisse être obtenue. Il semble que le succès soit facile.
Nous avons donc obtenu le code suivant :

<?php
/**
 * Class Crawler
 * Path: /Async/CrawlerV1.php
 */
class Crawler
{
    private $url;
    private $toVisit = [];
    private $loaded = false;
    public function __construct($url)
    {
        $this->url = $url;
    }
    public function visitOneDegree()
    {
        $this->visit($this->url, true);
        $retryCount = 3;
        do {
            sleep(1);
            $retryCount--;
        } while ($retryCount > 0 && $this->loaded == false);
        $this->visitAll();
    }
    private function loadPage($content)
    {
        $pattern = &#39;#((http|ftp)://(\S*?\.\S*?))([\s)\[\]{},;"\&#39;:<]|\.\s|$)#i&#39;;
        preg_match_all($pattern, $content, $matched);
        foreach ($matched[0] as $url) {
            if (in_array($url, $this->toVisit)) {
                continue;
            }
            $this->toVisit[] = $url;
        }
    }
    private function visitAll()
    {
        foreach ($this->toVisit as $url) {
            $this->visit($url);
        }
    }
    private function visit($url, $root = false)
    {
        $urlInfo = parse_url($url);
        Swoole\Async::dnsLookup($urlInfo[&#39;host&#39;], function ($domainName, $ip) use($urlInfo, $root) {
            $cli = new swoole_http_client($ip, 80);
            $cli->setHeaders([
                &#39;Host&#39; => $domainName,
                "User-Agent" => &#39;Chrome/49.0.2587.3&#39;,
                &#39;Accept&#39; => &#39;text/html,application/xhtml+xml,application/xml&#39;,
                &#39;Accept-Encoding&#39; => &#39;gzip&#39;,
            ]);
            $cli->get($urlInfo[&#39;path&#39;], function ($cli) use ($root) {
                if ($root) {
                    $this->loadPage($cli->body);
                    $this->loaded = true;
                }
            });
        });
    }
}

<?php
/**
 * crawler.php
 */
require_once &#39;Async/CrawlerV1.php&#39;;
$start = microtime(true);
$url = &#39;http://www.swoole.com/&#39;;
$ins = new Crawler($url);
$ins->visitOneDegree();
$timeUsed = microtime(true) - $start;
echo "time used: " . $timeUsed;
/* output:
time used: 3.011773109436
*/

Le résultat a duré 3 secondes. Faites attention à ma mise en œuvre. Après avoir lancé une demande d'exploration de la page d'accueil, j'interrogerai les résultats toutes les secondes, et cela se terminera après trois interrogations. Les 3 secondes ici semblent être la sortie provoquée par 3 sondages sans résultats.
Il semble que j’étais trop impatient et que je ne leur ai pas laissé suffisamment de temps de préparation. D'accord, modifions le nombre de sondages à 10 et voyons les résultats.

time used: 10.034232854843

Vous savez ce que je ressens en ce moment.

Est-ce un problème de performances avec swoole ? Pourquoi n'y a-t-il aucun résultat après 10 secondes ? Est-ce parce que ma posture est mauvaise ? Le vieux Marx disait : « La pratique est le seul critère pour tester la vérité. » Il semble que nous devions le déboguer pour en découvrir la raison.

Donc, j'ai ajouté des points d'arrêt à

$this->visitAll();

et

$this->loadPage($cli->body);

. Enfin, j'ai trouvé que visitAll() est toujours exécuté en premier, puis loadPage() est exécuté.

Après y avoir réfléchi un moment, je comprends probablement la raison. Quelle en est la raison ?

Le modèle dynamique asynchrone auquel je m'attendais est comme ceci :

Cependant, le scénario réel n'est pas comme ça. Grâce au débogage, j'ai à peu près compris que le modèle réel devrait ressembler à ceci :

En d'autres termes, peu importe la façon dont j'augmente le nombre de tentatives, les données ne seront jamais prêtes. Les données ne commenceront à s'exécuter qu'une fois la fonction actuelle prête. L'asynchrone ici ne fait que réduire le temps de préparation de la connexion.
Ensuite, la question est de savoir comment faire en sorte que le programme exécute les fonctions que j'attends après avoir préparé les données.
Voyons d'abord comment est écrit le code officiel de Swoole pour l'exécution de tâches asynchrones.

$serv = new swoole_server("127.0.0.1", 9501);
//设置异步任务的工作进程数量
$serv->set(array('task_worker_num' => 4));
$serv->on('receive', function($serv, $fd, $from_id, $data) {
    //投递异步任务
    $task_id = $serv->task($data);
    echo "Dispath AsyncTask: id=$task_id\n";
});
//处理异步任务
$serv->on('task', function ($serv, $task_id, $from_id, $data) {
    echo "New AsyncTask[id=$task_id]".PHP_EOL;
    //返回任务执行的结果
    $serv->finish("$data -> OK");
});
//处理异步任务的结果
$serv->on('finish', function ($serv, $task_id, $data) {
    echo "AsyncTask[$task_id] Finish: $data".PHP_EOL;
});
$serv->start();

Vous pouvez voir que le responsable transmet la logique d'exécution ultérieure via une fonction anonyme. Vu sous cet angle, les choses deviennent beaucoup plus simples.

url = $url;
    }
    public function visitOneDegree()
    {
        $this->visit($this->url, function ($content) {
            $this->loadPage($content);
            $this->visitAll();
        });
    }
    private function loadPage($content)
    {
        $pattern = '#((http|ftp)://(\S*?\.\S*?))([\s)\[\]{},;"\':<]|\.\s|$)#i';
        preg_match_all($pattern, $content, $matched);
        foreach ($matched[0] as $url) {
            if (in_array($url, $this->toVisit)) {
                continue;
            }
            $this->toVisit[] = $url;
        }
    }
    private function visitAll()
    {
        foreach ($this->toVisit as $url) {
            $this->visit($url);
        }
    }
    private function visit($url, $callBack = null)
    {
        $urlInfo = parse_url($url);
        Swoole\Async::dnsLookup($urlInfo['host'], function ($domainName, $ip) use($urlInfo, $callBack) {
            if (!$ip) {
                return;
            }
            $cli = new swoole_http_client($ip, 80);
            $cli->setHeaders([
                'Host' => $domainName,
                "User-Agent" => 'Chrome/49.0.2587.3',
                'Accept' => 'text/html,application/xhtml+xml,application/xml',
                'Accept-Encoding' => 'gzip',
            ]);
            $cli->get($urlInfo['path'], function ($cli) use ($callBack) {
                if ($callBack) {
                    call_user_func($callBack, $cli->body);
                }
                $cli->close();
            });
        });
    }
}

Après avoir lu ce code, je ressens un sentiment de déjà-vu. Dans le développement de nodejs, les rappels omniprésents ont leurs propres raisons. Maintenant, je comprends soudain que le rappel existe pour résoudre des problèmes asynchrones.
J'ai exécuté le programme et cela n'a pris que 0,0007s, et c'était terminé avant même de commencer ! L’efficacité asynchrone peut-elle vraiment être améliorée à ce point ? La réponse est bien sûr non, il y a quelque chose qui ne va pas avec notre code.
Grâce à l'utilisation de l'asynchrone, la logique de calcul de l'heure de fin a été exécutée sans attendre que la tâche soit complètement terminée. Il semble qu'il soit temps d'utiliser à nouveau le rappel.

/**
Async/Crawler.php
**/
    public function visitOneDegree($callBack)
    {
        $this->visit($this->url, function ($content) use($callBack) {
            $this->loadPage($content);
            $this->visitAll();
            call_user_func($callBack);
        });
    }

<?php
/**
 * crawler.php
 */
require_once &#39;Async/Crawler.php&#39;;
$start = microtime(true);
$url = &#39;http://www.swoole.com/&#39;;
$ins = new Crawler($url);
$ins->visitOneDegree(function () use($start) {
    $timeUsed = microtime(true) - $start;
    echo "time used: " . $timeUsed;
});
/*output:
time used: 0.068463802337646
*/

En y regardant maintenant, les résultats sont beaucoup plus crédibles.
Comparons la différence entre synchrone et asynchrone. La synchronisation prend 6,26 s et l'asynchrone prend 0,068 seconde, soit une différence totale de 6,192 s. Non, pour le dire plus précisément, cela devrait être près de 10 fois pire !
Bien sûr, en termes d'efficacité, le code asynchrone est bien supérieur au code synchrone, mais logiquement parlant, la logique asynchrone est plus compliquée que la logique synchrone, et le code apportera beaucoup de rappels, ce qui n'est pas facile à comprendre.
Swoole Official a une description sur le choix de l'asynchrone et du synchrone, qui est très pertinente. J'aimerais la partager avec vous :

我们不赞成用异步回调的方式去做功能开发，传统的PHP同步方式实现功能和逻辑是最简单的，也是最佳的方案。像node.js这样到处callback，只是牺牲可维护性和开发效率。

Lecture connexe :

Comment installer l'extension swoole avec php7

Introduction aux points de développement Swoole

Exemple d'utilisation de swoole multithread asynchrone PHP

Ce qui précède est tout le contenu de cet article. Si les étudiants ont des questions, ils peuvent en discuter dans le. zone de commentaires ci-dessous ~

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!