Comment implémenter le traitement de concurrence sous-jacent en PHP

Comment implémenter le traitement simultané au bas de PHP nécessite des exemples de code spécifiques

Dans le processus de développement Web, il est souvent nécessaire de gérer un grand nombre de requêtes simultanées si le traitement simultané n'est pas utilisé, cela entraînera des problèmes. temps de réponse longs et pression excessive du serveur. PHP est un langage de développement Web. Sa prise en charge multithread intégrée est relativement faible, mais il peut réaliser un traitement simultané sous-jacent via d'autres méthodes.

1. Introduction au principe

En PHP, chaque requête sera traitée par un nouveau processus ou thread ouvert par le serveur web. Afin d'améliorer la concurrence, des méthodes multi-processus ou multi-thread peuvent être utilisées en bas pour traiter plusieurs requêtes en même temps, obtenant ainsi l'effet d'améliorer la concurrence.

La méthode multi-processus est implémentée en créant un processus enfant via la fonction fork. Le processus enfant héritera du contexte (variables, descripteurs de fichiers, etc.) du processus parent et pourra partager la mémoire. Le multithreading est implémenté via l'extension pthread, qui fournit une API pour créer des threads pouvant partager le contexte du processus.

2. Bibliothèque pour implémenter le traitement simultané

1. Swoole

Swoole est une extension écrite en C, qui fournit un cadre de programmation réseau hautes performances, asynchrone et piloté par événements qui peut nous aider à implémenter rapidement la concurrence sous-jacente dans les transactions PHP. avec. Swoole prend en charge les protocoles TCP/UDP/Unix Socket asynchrones, les serveurs HTTP/WebSocket, ainsi que les requêtes asynchrones MySQL, Redis, DNS et d'autres fonctions.

Ce qui suit est un exemple de serveur HTTP simple implémenté à l'aide de Swoole :

<?php
$http = new swoole_http_server("0.0.0.0", 9501);

$http->on("start", function ($server) {
    echo "Swoole http server is started at http://127.0.0.1:9501
";
});

$http->on("request", function ($request, $response) {
    $response->header("Content-Type", "text/plain");
    $response->end("Hello Swoole!");
});

$http->start();

2. Amp

Amp est un framework de programmation asynchrone basé sur PHP, qui fournit un ensemble de coroutines et d'API IO asynchrones non bloquantes pour nous aider implémenter le traitement de concurrence de bas niveau. Amp prend en charge les protocoles TCP/UDP/Unix Socket asynchrones, les clients HTTP/HTTPS, les serveurs et les fonctions asynchrones MySQL, PostgreSQL, Redis, Memcached et autres.

Ce qui suit est un exemple de serveur HTTP simple implémenté à l'aide d'Amp :

<?php
require 'vendor/autoload.php';

use AmpHttpServerHttpServer;
use AmpHttpServerRequestHandlerCallableRequestHandler;
use AmpHttpServerResponse;
use AmpHttpStatus;

$server = new HttpServer([new CallableRequestHandler(function () {
    return new Response(Status::OK, ['content-type' => 'text/plain'], 'Hello, world!');
})]);

$socket = AmpSocketlisten('0.0.0.0:9501');

$server->listen($socket);

AmpLoop::run();

3. Exemple de code multi-processus/multi-thread sous-jacent

L'utilisation de l'extension PCNTL peut très facilement implémenter la programmation multi-processus en PHP. est un exemple multi-processus simple :

<?php
$workerNum = 3; // 子进程数量

// 父进程等待子进程结束并回收资源
for ($i = 0; $i < $workerNum; $i++) {
    $pid = pcntl_fork();
    if ($pid < 0) {
        // 创建子进程失败
        exit('fork failed');
    } elseif ($pid == 0) {
        // 子进程代码
        echo 'worker ', $i, " pid is ", posix_getpid(), "
";
        // 这里是子进程具体的处理逻辑
        sleep(10);
        exit(0);
    }
}

while (($ret = pcntl_waitpid(-1, $status, WNOHANG)) != -1) {
    // 回收子进程资源
    if ($ret > 0) {
        echo "worker ", $ret, " exit with status ", $status, "
";
    } else {
        break;
    }
}

L'utilisation de l'extension pthreads peut facilement implémenter une programmation multi-thread en PHP. Voici un exemple multi-thread simple :

<?php
class MyWorker extends Thread {
    public function run() {
        echo 'Worker ', $this->getThreadId(), " starts
";
        // 这里是子线程具体的处理逻辑
        sleep(10);
        echo 'Worker ', $this->getThreadId(), " ends
";
    }
}

$workerNum = 3; // 子线程数量

$workers = [];
for ($i = 0; $i < $workerNum; $i++) {
    $workers[] = new MyWorker();
}

foreach ($workers as $worker) {
    $worker->start();
}

foreach ($workers as $worker) {
    $worker->join();
}

Les éléments ci-dessus sont deux multi-processus/de bas niveau couramment utilisés. méthodes de programmation multithread. Bien entendu, vous pouvez également utiliser des méthodes plus avancées, telles que l'utilisation de frameworks tiers tels que ReactPHP et Workerman. Dans les applications réelles, il est nécessaire de choisir une solution appropriée en fonction des scénarios commerciaux et des besoins pour réaliser le traitement simultané sous-jacent de PHP.

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!