Implémentation d'un serveur à haute concurrence avec PHP

En matière de concurrence élevée, il n'existe aucun moyen de contourner le multiplexage d'E/S, puis de spécifier la plate-forme spécifique. Linux, il n'y a aucun moyen de contourner epoll. Je n'entrerai pas dans les détails de l'efficacité d'epoll. Les étudiants intéressés peuvent le rechercher et l'étudier par eux-mêmes.

Comment jouer à epoll avec PHP ? Tout d'abord, vous devez installer la bibliothèque libevent, puis installer l'extension d'événement ou l'extension libevent et vous pourrez jouer joyeusement

Certaines personnes ne comprennent pas la différence entre la bibliothèque libevent et l'extension libevent. En termes simples, la bibliothèque libevent C'est l'encapsulation d'epoll en langage C et n'a rien à voir avec PHP ; l'extension libevent est le pont de communication entre PHP et la bibliothèque libevent. En fait, de nombreuses extensions de PHP le font. Il existe d'excellentes bibliothèques de langage C. Si PHP souhaite les utiliser directement, il peut être connecté à PHP via des extensions PHP.

Choisissez soit l'extension libevent, soit l'extension event. Personnellement, je préfère l'extension event car elle est plus orientée objet. Allez sur http://pecl.php.net et recherchez les extensions correspondant à votre version de PHP, téléchargez-la, compilez-la et installez-la et tout ira bien. Lors de la compilation avec plusieurs versions de PHP installées sur votre ordinateur, faites attention aux. version de phpize qui correspond à celle. , ne vous y trompez pas, les cinq étapes typiques :

phpize
./configure
make
make install
php -m | grep event #看看装上了没

La couche de transport du serveur que nous voulons implémenter est le protocole TCP. Il y a trop de protocoles de couche application et il y en a trop. compliqué. En raison des limitations d'espace, nous utiliserons simplement le serveur HTTP comme exemple. Par exemple, le protocole HTTP lui-même est très complexe, et nous n'implémenterons pas entièrement le protocole HTTP.

Tout d'abord, créez un socket, trois étapes, socket_create, socket_bind, socket_listen Pourquoi ces trois étapes ? C'est très simple. Quel que soit votre protocole de couche transport, vous devez choisir une version du protocole de couche réseau ci-dessous, IPV4 ou IPV6, et vous devez choisir une méthode de travail de couche transport, full duplex, half duplex ou simplex, TCP. Ou UDP, vous devez en choisir une, socket_create ce sont ces trois options ; après avoir déterminé la couche réseau et la couche transport, vous devez me dire quel port écouter, ce qui correspond à socket_bind puis vous devez activer la surveillance et spécifier un client ; Longueur de la file d'attente, c'est ce que fait socket_listen.

Après la création, nous n'introduireons pas de blocage synchrone. Un processus peut contenir au plus une connexion à la fois, si vous demandez plus de connexions en même temps, vous devez attendre si la longueur de la file d'attente est spécifiée par socket_listen. est dépassé, 504 sera renvoyé. Il en va de même pour plusieurs processus. Plusieurs processus ont plusieurs processus simultanés. Les processus sont des ressources coûteuses, et le changement de contexte des processus prend du temps et est laborieux, ce qui entraîne une inefficacité de l'ensemble du système.

Ce n'est pas grave, nous avons epoll, ce n'est pas un rêve de contenir des milliers de requêtes, implémentez d'abord un Reactor. La bibliothèque libevent est le mode Reactor. L'appel direct de la fonction utilise le mode Reactor, il n'y a donc pas lieu de s'inquiéter de la façon d'implémenter le mode Reactor en PHP.

<?php

use Event;
use EventBase;

class Reactor
{
    protected $reactor;

    protected $events;

    public static $instance = null;

    const READ = Event::READ | Event::PERSIST;

    const WRITE = Event::WRITE | Event::PERSIST;

    public static function getInstance()
    {
        if (is_null(self::$instance)) {
            self::$instance = new self();
            self::$instance->reactor = new EventBase;
        }

        return self::$instance;
    }

    public function add($fd, $what, $cb, $arg = null)
    {
        switch ($what) {
            case self::READ:
                $event = new Event($this->reactor, $fd, self::READ, $cb, $arg);
                break;
            case self::WRITE:
                $event = new Event($this->reactor, $fd, self::WRITE, $cb, $arg);
                break;
            default:
                $event = new Event($this->reactor, $fd, $what, $cb, $arg);
                break;
        }

        $event->add();
        $this->events[(int) $fd][$what] = $event;
    }

    public function del($fd, $what = 'all')
    {
        $events = $this->events[(int) $fd];
        if ($what == 'all') {
            foreach ($events as $event) {
                $event->free();
            }
        } else {
            if ($what != self::READ && $what != self::WRITE) {
                throw new \Exception('不存在的事件');
            }

            $events[$what]->free();
        }
    }

    public function run()
    {
        $this->reactor->loop();
    }

    public function stop()
    {
        foreach ($this->events as $events) {
            foreach ($events as $event) {
                $event->free();
            }
        }
        $this->reactor->stop();
    }
}

Le code ci-dessus est très simple. Laissez-moi vous expliquer brièvement le concept. EventBase est un conteneur qui contient des instances d'événement. De cette façon, le code ci-dessus est très facile à comprendre. Ensuite, un Server.

<?php use Throwable;use Monolog\Handler\StreamHandler;class Server{	protected $ip;	protected $port;	protected $socket;	protected $reactor;	public function __construct($ip, $port)
	{		$this->ip = $ip;		$this->port = $port;
	}	public function start()
	{
	    $socket = $this->createTcpConnection();
	    stream_set_blocking($socket, false);

	    Reactor::getInstance()->add($socket, Reactor::READ, function($socket) {
                $conn = stream_socket_accept($socket);
                stream_set_blocking($conn, false);
                (new Connection($conn))->handle();
        });

            Reactor::getInstance()->run();
	}	public function createTcpConnection()
	{
		$schema = sprintf("tcp://%s:%d", $this->ip, $this->port);
		$socket = stream_socket_server($schema, $errno, $errstr);		if ($errno) {			throw new \Exception($errstr);
		}		return $socket;
	}
}

Connection

<?phpclass Connection{    protected $conn;    protected $read_buffer = &#39;&#39;;    protected $write_buffer = &#39;&#39;;    public function __construct($conn)
    {        $this->conn = $conn;
    }    public function handle()
    {
        Reactor::getInstance()->add($this->conn, Reactor::READ, \Closure::fromCallable([$this, 'read']));
    }    private function read($conn)
    {        $this->read_buffer = '';        if (is_resource($conn)) {            while ($content = fread($conn, 65535)) {                $this->read_buffer .= $content;
            }
        }        if ($this->read_buffer) {
            Reactor::getInstance()->add($conn, Reactor::WRITE, \Closure::fromCallable([$this, 'write']));
        } else {
            Reactor::getInstance()->del($conn);
            fclose($conn);
        }
    }    private function write($conn)
    {        if (is_resource($conn)) {
            fwrite($conn, "HTTP/1.1 200 OK\r\nContent-Type: text/html;charset=utf8\r\nContent-Length:11\r\nConnection: keep-alive\r\n\r\nHello!world");
        }
    }

}

crée d'abord un Socket en trois étapes et le met en mode non bloquant. Ajoutez ensuite le socket au Reactor pour écouter les événements lisibles. Lisible signifie qu'il ne peut être lu que lorsqu'il y a des données dans le tampon. Un événement lisible se produit, indiquant qu'une nouvelle connexion arrive. Utilisez stream_socket_accept pour recevoir la nouvelle connexion Conn et placez Conn dans Reactor pour surveiller les événements lisibles, indiquant que le client a envoyé des données lues. une boucle jusqu'à ce qu'il n'y ait plus de données, puis placez Conn dans Reactor pour écouter les événements inscriptibles, cela signifie que les données client ont été envoyées. Assemblez le protocole et écrivez la réponse.

Si la couche d'application est le protocole HTTP, veuillez faire attention à l'en-tête Connection: keep-alive. Étant donné que la connexion doit être réutilisée, ne fermez pas la connexion dès qu'elle est terminée.

Une fois le travail terminé, utilisez ab pour tester la concurrence et ajoutez -k la connexion de réutilisation des paramètres. Il n'y a aucun problème avec la concurrence i5+8G, 3W. Bien sûr, nous n'avons pas de disque. E/S ici. La situation réelle est que la lecture de fichiers à partir du disque nécessite des appels système Linux, et il existe plusieurs opérations de copie de fichiers, ce qui est relativement coûteux. La solution courante est l'envoi de fichiers directement d'un FD à un autre FD. est plus efficace, l'inconvénient est que PHP n'a pas d'extensions sendfile prêtes à l'emploi, vous devez donc le faire vous-même et le coût de développement est un peu élevé.

Photo PO test ab :

C'est l'idée d'implémenter un serveur à haute concurrence en PHP. Tant qu'il est résolu avec EPOLL, l'idée est la même. C'est un processus en trois étapes. Mettez-le sous Reactor pour le surveiller. Événements FD. Bien sûr, ce n'est que le modèle le plus simple, et de nombreux domaines peuvent être améliorés. Par exemple, multi-processus, copie nginx, un processus principal + N processus de travail, le but du multi-processus est d'utiliser le multicœur. travail parallèle. La même chose est vraie pour l'implémentation du langage C, mais vous ne pouvez pas utiliser la bibliothèque libevent et encapsuler EPOLL vous-même. Après tout, la bibliothèque libevent est un peu lourde et vous ne pouvez pas utiliser beaucoup de choses dans libevent, bien sûr, le langage C ; a un tas de structures de données et de fonctions définies sur les structures de données. Les opérations doivent être écrites, il n'y a pas de GC, la mémoire doit être gérée par vous-même et il doit y avoir une bonne conception. Lorsque vous exécutez plusieurs processus, vous devez également le faire. Travailler sur la communication inter-processus IPC. La difficulté de développement est bien plus grande que celle de PHP, et le cycle de développement est également très long. Ceux qui sont intéressés Les étudiants peuvent jouer avec un seul.

Pour plus d'articles techniques liés à PHP, veuillez visiter la colonne Tutoriel PHP pour apprendre !

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!