Français
Français
Lors du traitement des demandes simultanées élevées, PHP, en tant que langage de script côté serveur, doit souvent faire face à des problèmes de blocage des demandes, en particulier lorsqu'un grand nombre d'opérations d'E / S sont nécessaires (telles que les demandes de réseau, la lecture et l'écriture de fichiers, etc.). La fonction SOCKET_SET_BLOCKING est un outil utile en PHP qui peut aider les développeurs à contrôler efficacement le comportement de blocage des sockets, améliorant ainsi la capacité de traitement des demandes simultanées. Cet article présentera comment utiliser la fonction socket_set_blocking pour optimiser le traitement de la demande simultané de PHP.
socket_set_blocking est une fonction utilisée pour contrôler si le socket est en mode de blocage. Par défaut, les prises exécutées en mode de blocage, c'est-à-dire lorsqu'une opération de socket (comme la lecture ou l'écriture de données) n'a pas de données, elle fait attendre le programme que les données soient disponibles. En définissant la prise sur le mode non bloquant, le programme peut continuer à effectuer d'autres tâches au lieu d'attendre l'achèvement d'une certaine opération d'E / S.
bool socket_set_blocking ( resource $socket , bool $blocking )
$ socket : la ressource de socket qui doit être définie.
$ Blocking : Si vrai , définissez la prise sur le mode de blocage; Si faux , définissez la prise sur le mode non bloquant.
Les modèles de blocage traditionnels peuvent conduire à des goulots d'étranglement des performances du système lors de la gestion d'un grand nombre de demandes simultanées. En définissant la prise sur le mode non bloquant, le script PHP peut continuer à traiter d'autres demandes en attendant une opération de socket. Voici comment réaliser un traitement efficace de demande simultanée via socket_set_blocking :
En supposant que nous devons traiter plusieurs demandes de clients et que nous voulons éviter de bloquer lors du traitement de chaque demande, voici un exemple simple de code:
<?php
// créerTCP socket
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
socket_set_option($socket, SOL_SOCKET, SO_REUSEADDR, 1);
// Liersocket
socket_bind($socket, '127.0.0.1', 8080);
// Commencer à surveiller
socket_listen($socket);
// Réglé sur le mode non bloquant
socket_set_blocking($socket, false);
while (true) {
// Recevoir les connexions du client
$client = socket_accept($socket);
// S'il n'y a pas de connexion, continuez à effectuer d'autres opérations
if ($client === false) {
// Par exemple, vérifiez d'autres tâches ou effectuez des opérations de journalisation telles que
echo "Aucune connexion client，Continuez à travailler sur d'autres tâches...\n";
continue;
}
// Définissez le client sur le non-bloquant
socket_set_blocking($client, false);
// Lire les données du client
$input = socket_read($client, 1024);
if ($input) {
echo "Données du client reçu: $input\n";
// Traiter la demande et répondre
socket_write($client, "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nHello, Client!");
}
// Fermer la connexion
socket_close($client);
}
socket_close($socket);
?>
Dans le code ci-dessus, nous définissons le socket côté serveur en mode non bloquant par socket_set_blocking ($ socket, false) , ce qui signifie que lorsqu'aucune demande du client ne vient, socket_accept ne bloquera pas et n'attendra pas, mais il reviendra faux . Cela permet au programme de continuer à effectuer d'autres tâches sans connexion client sans rester sur socket_accept .
De même, lors de la gestion de chaque connexion client, nous définissons également le socket client en mode non bloquant, afin que l'ensemble du programme ne soit pas bloqué lors de la lecture des données et peut améliorer la capacité de traitement des demandes simultanées.
Dans des scénarios de concurrence élevés, via des opérations de socket non bloquantes, les méthodes Socket_Select ou multi-thread / multi-processus peuvent être utilisées pour traiter plusieurs demandes simultanées plus efficacement. Socket_Select est une fonction très utile qui peut surveiller plusieurs ressources de socket, garantissant que seules les prises lisibles sont traitées, évitant le blocage inutile.
<?php
// créer主socket
$masterSocket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
socket_set_option($masterSocket, SOL_SOCKET, SO_REUSEADDR, 1);
socket_bind($masterSocket, '127.0.0.1', 8080);
socket_listen($masterSocket);
// Définir le non-bloque
socket_set_blocking($masterSocket, false);
$clients = array($masterSocket);
while (true) {
// utilisersocket_selectEffectuer une surveillance
$read = $clients;
$write = null;
$except = null;
// moniteursocket
if (socket_select($read, $write, $except, null) > 0) {
// Itérer à travers toutes les donnéessocket
foreach ($read as $socket) {
if ($socket === $masterSocket) {
// Acceptez de nouvelles connexions
$client = socket_accept($masterSocket);
socket_set_blocking($client, false);
$clients[] = $client;
} else {
// Lire les données du client
$input = socket_read($socket, 1024);
if ($input === false) {
// Débrancher
socket_close($socket);
$clients = array_diff($clients, array($socket));
} else {
echo "Données reçues: $input\n";
socket_write($socket, "Hello, Client!");
}
}
}
}
}
socket_close($masterSocket);
?>
Dans cet exemple, la fonction Socket_Select est utilisée pour surveiller simultanément plusieurs connexions de socket. Lorsqu'une prise est disponible, le programme lit les données et les traite. De cette façon, le serveur peut traiter plusieurs demandes simultanées en même temps sans bloquer le traitement d'autres demandes en raison d'une demande.
L'utilisation de la fonction SOCKET_SET_BLOCKING pour définir Socket sur le mode non bloquant est un moyen important d'améliorer l'efficacité du traitement de la demande simultanée PHP. En configurant rationnellement le mode de blocage et en utilisant les fonctions Socket_Select , les développeurs peuvent obtenir un traitement de demande concurrent efficace en PHP pour éviter les goulots d'étranglement des performances causés par le mode de blocage traditionnel. L'optimisation des opérations d'E / S est la clé pour améliorer les performances des applications qui doivent gérer un grand nombre de connexions simultanées.
