Parallelitäts- und Multithreading-Techniken für PHP-Crawler

Parallelität und Multithread-Verarbeitungsfähigkeiten von PHP-Crawlern

Einführung:
Mit der rasanten Entwicklung des Internets werden große Mengen an Dateninformationen auf verschiedenen Websites gespeichert, und die Beschaffung dieser Daten ist in vielen Unternehmen zu einer Anforderung geworden Szenarien. Als Werkzeug zum automatischen Abrufen von Netzwerkinformationen werden Crawler häufig in der Datenerfassung, in Suchmaschinen, bei der Analyse der öffentlichen Meinung und in anderen Bereichen eingesetzt. In diesem Artikel wird eine Parallelitäts- und Multithreading-Verarbeitungstechnik für eine PHP-basierte Crawler-Klasse vorgestellt und deren Implementierung anhand von Codebeispielen veranschaulicht.

1. Die Grundstruktur der Reptilienklasse
Bevor wir die Parallelität und Multithread-Verarbeitung der Reptilienklasse implementieren, werfen wir zunächst einen Blick auf die Struktur einer grundlegenden Reptilienklasse.

class Crawler {
    private $startUrl;

    public function __construct($startUrl) {
        $this->startUrl = $startUrl;
    }

    public function crawl() {
        // 获取初始页面的内容
        $content = $this->getContent($this->startUrl);

        // 解析页面内容，获取需要的信息
        $data = $this->parseContent($content);

        // 处理获取到的信息，进行业务逻辑处理或存储
        $this->processData($data);

        // 获取页面中的链接，并递归抓取
        $urls = $this->getUrls($content);
        foreach ($urls as $url) {
            $content = $this->getContent($url);
            $data = $this->parseContent($content);
            $this->processData($data);
        }
    }

    private function getContent($url) {
        // 发起HTTP请求，获取页面内容
        // ...
        return $content;
    }

    private function parseContent($content) {
        // 解析页面内容，提取需要的信息
        // ...
        return $data;
    }

    private function processData($data) {
        // 处理获取到的信息，进行逻辑处理或存储
        // ...
    }

    private function getUrls($content) {
        // 获取页面中的链接
        // ...
        return $urls;
    }
}

Im obigen Code definieren wir zunächst eine Crawler-Klasse und übergeben eine Start-URL über den Konstruktor. In der crawl()-Methode rufen wir zunächst den Inhalt der Startseite ab, analysieren dann den Seiteninhalt und extrahieren die erforderlichen Informationen. Anschließend können wir die gewonnenen Informationen weiterverarbeiten, beispielsweise in einer Datenbank speichern. Schließlich erhalten wir die Links auf der Seite und crawlen rekursiv andere Seiten.

2. Gleichzeitige Verarbeitung
Normalerweise müssen Crawler eine große Anzahl von URLs verarbeiten, und die E/A-Vorgänge von Netzwerkanforderungen sind sehr zeitaufwändig. Wenn wir eine sequentielle Ausführung verwenden, verringert die Anforderung der nächsten Anforderung nach Abschluss einer Anforderung unsere Crawling-Effizienz erheblich. Um die Möglichkeiten der gleichzeitigen Verarbeitung zu verbessern, können wir die Multiprozesserweiterung von PHP verwenden, um dies zu erreichen.

class ConcurrentCrawler {
    private $urls;

    public function __construct($urls) {
        $this->urls = $urls;
    }

    public function crawl() {
        $workers = [];
        $urlsNum = count($this->urls);
        $maxWorkersNum = 10; // 最大进程数

        for ($i = 0; $i < $maxWorkersNum; $i++) {
            $pid = pcntl_fork();
            if ($pid == -1) {
                die('fork failed');
            } else if ($pid == 0) {
                for ($j = $i; $j < $urlsNum; $j += $maxWorkersNum) {
                    $this->processUrl($this->urls[$j]);
                }
                exit();
            } else {
                $workers[$pid] = true;
            }
        }

        while (count($workers)) {
            $pid = pcntl_wait($status, WUNTRACED);
            if ($status == 0) {
                unset($workers[$pid]);
            } else {
                $workers[$pid] = false;
            } 
        }
    }

    private function processUrl($url) {
        // 发起HTTP请求，获取页面内容
        // ...
        // 解析页面内容，获取需要的信息
        // ...
        // 处理获取到的信息，进行逻辑处理或存储
        // ...
    }
}

Im obigen Code definieren wir zunächst eine ConcurrentCrawler-Klasse und übergeben eine Reihe von URLs, die durch den Konstruktor gecrawlt werden müssen. In der crawl()-Methode verwenden wir die Multiprozessmethode für die gleichzeitige Verarbeitung. Durch die Verwendung der Funktion pcntl_fork() wird ein Teil der URL in jedem untergeordneten Prozess verarbeitet, während der übergeordnete Prozess für die Verwaltung des untergeordneten Prozesses verantwortlich ist. Warten Sie abschließend mit der Funktion pcntl_wait() auf das Ende aller untergeordneten Prozesse.

3. Multithread-Verarbeitung
Zusätzlich zur Verwendung mehrerer Prozesse für die gleichzeitige Verarbeitung können wir auch die Thread-Erweiterung von PHP verwenden, um Multithread-Verarbeitung zu implementieren.

class MultithreadCrawler extends Thread {
    private $url;

    public function __construct($url) {
        $this->url = $url;
    }

    public function run() {
        // 发起HTTP请求，获取页面内容
        // ...
        // 解析页面内容，获取需要的信息
        // ...
        // 处理获取到的信息，进行逻辑处理或存储
        // ...
    }
}

class Executor {
    private $urls;

    public function __construct($urls) {
        $this->urls = $urls;
    }

    public function execute() {
        $threads = [];
        foreach ($this->urls as $url) {
            $thread = new MultithreadCrawler($url);
            $thread->start();
            $threads[] = $thread;
        }

        foreach ($threads as $thread) {
            $thread->join();
        }
    }
}

Im obigen Code definieren wir zunächst eine MultithreadCrawler-Klasse, die von der Thread-Klasse erbt und die run()-Methode als Hauptlogik des Threads neu schreibt. In der Executor-Klasse erstellen wir mehrere Threads über eine Schleife und starten sie zur Ausführung. Warten Sie abschließend mit der Methode join () auf das Ende aller Threads.

Schlussfolgerung:
Durch die Einführung von Parallelitäts- und Multithread-Verarbeitungstechniken von PHP-Crawlern können wir feststellen, dass sowohl die Parallelitätsverarbeitung als auch die Multithread-Verarbeitung die Crawling-Effizienz des Crawlers erheblich verbessern können. Im eigentlichen Entwicklungsprozess müssen wir jedoch die geeignete Verarbeitungsmethode entsprechend der spezifischen Situation auswählen. Gleichzeitig müssen wir während der Verarbeitung auch entsprechende Synchronisationsvorgänge durchführen, um die Sicherheit von Multithreads oder Multiprozessen zu gewährleisten.

Das obige ist der detaillierte Inhalt vonParallelitäts- und Multithreading-Techniken für PHP-Crawler. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!