Explication détaillée de la programmation SOCKET en PHP

本文主要和大家分享PHP之SOCKET编程详解，主要结合文字和代码的形式和大家分享，希望能帮助到大家。

1. 预备知识

       一直以来很少看到有多少人使用php的socket模块来做一些事情，大概大家都把它定位在脚本语言的范畴内吧，但是其实php的socket模块可以做很多事情，包括做ftplist,http post提交，smtp提交，组包并进行特殊报文的交互（如smpp协议），whois查询。这些都是比较常见的查询。

特别是php的socket扩展库可以做的事情简直不会比c差多少。
php的socket连接函数
1、集成于内核的socket
这个系列的函数仅仅只能做主动连接无法实现端口监听相关的功能。而且在4.3.0之前所有socket连接只能工作在阻塞模式下。
此系列函数包括
fsockopen，pfsockopen
这两个函数的具体信息可以查询php.net的用户手册
他们均会返回一个资源编号对于这个资源可以使用几乎所有对文件操作的函数对其进行操作如fgets(),fwrite(), fclose()等单注意的是所有函数遵循这些函数面对网络信息流时的规律，例如：
fread() 从文件指针 handle 读取最多 length 个字节。 该函数在读取完 length 个字节数，或到达 EOF 的时候，或（对于网络流）当一个包可用时就会停止读取文件，视乎先碰到哪种情况。 
可以看出对于网络流就必须注意取到的是一个完整的包就停止。
2、php扩展模块带有的socket功能。
php4.x 以后有这么一个模块extension=php_sockets.dll，Linux上是一个extension=php_sockets.so。
当打开这个此模块以后就意味着php拥有了强大的socket功能，包括listen端口，阻塞及非阻塞模式的切换，multi-client 交互式处理等
这个系列的函数列表参看http://www.php.net/manual/en/ref.sockets.php
看过这个列表觉得是不是非常丰富呢？不过非常遗憾这个模块还非常年轻还有很多地方不成熟，相关的参考文档也非常少：（
我也正在研究中，因此暂时不具体讨论它，仅给大家一个参考文章。

2. 使用PHP socket扩展

服务器端代码：

<?php
/**
 * File name server.php
 * 服务器端代码
 * 
 * @author guisu.huang
 * @since 2012-04-11
 * 
 */

//确保在连接客户端时不会超时
set_time_limit(0);
//设置IP和端口号
$address = "127.0.0.1";
$port = 2046; //调试的时候，可以多换端口来测试程序！
/**
 * 创建一个SOCKET 
 * AF_INET=是ipv4 如果用ipv6，则参数为 AF_INET6
 * SOCK_STREAM为socket的tcp类型，如果是UDP则使用SOCK_DGRAM
*/
$sock = socket_create(AF_INET, SOCK_STREAM, SOL_TCP) or die("socket_create() 失败的原因是:" . socket_strerror(socket_last_error()) . "/n");
//阻塞模式
socket_set_block($sock) or die("socket_set_block() 失败的原因是:" . socket_strerror(socket_last_error()) . "/n");
//绑定到socket端口
$result = socket_bind($sock, $address, $port) or die("socket_bind() 失败的原因是:" . socket_strerror(socket_last_error()) . "/n");
//开始监听
$result = socket_listen($sock, 4) or die("socket_listen() 失败的原因是:" . socket_strerror(socket_last_error()) . "/n");
echo "OK\nBinding the socket on $address:$port ... ";
echo "OK\nNow ready to accept connections.\nListening on the socket ... \n";
do { // never stop the daemon
	//它接收连接请求并调用一个子连接Socket来处理客户端和服务器间的信息
	$msgsock = socket_accept($sock) or  die("socket_accept() failed: reason: " . socket_strerror(socket_last_error()) . "/n");
	
	//读取客户端数据
	echo "Read client data \n";
	//socket_read函数会一直读取客户端数据,直到遇见\n,\t或者\0字符.PHP脚本把这写字符看做是输入的结束符.
	$buf = socket_read($msgsock, 8192);
	echo "Received msg: $buf   \n";
	
	//数据传送 向客户端写入返回结果
	$msg = "welcome \n";
	socket_write($msgsock, $msg, strlen($msg)) or die("socket_write() failed: reason: " . socket_strerror(socket_last_error()) ."/n");
	//一旦输出被返回到客户端,父/子socket都应通过socket_close($msgsock)函数来终止
    socket_close($msgsock);
} while (true);
socket_close($sock);

客户端代码：

<?php
/**
 * File name:client.php
 * 客户端代码
 * 
 * @author guisu.huang
 * @since 2012-04-11
 */
set_time_limit(0);

$host = "127.0.0.1";
$port = 2046;
$socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP)or die("Could not create	socket\n"); // 创建一个Socket
 
$connection = socket_connect($socket, $host, $port) or die("Could not connet server\n");    //  连接
socket_write($socket, "hello socket") or die("Write failed\n"); // 数据传送 向服务器发送消息
while ($buff = socket_read($socket, 1024, PHP_NORMAL_READ)) {
    echo("Response was:" . $buff . "\n");
}
socket_close($socket);

使用cli方式启动server：

php server.php

这里注意socket_read函数：

可选的类型参数是一个命名的常数：
PHP_BINARY_READ - 使用系统recv（）函数。用于读取二进制数据的安全。 （在PHP>“默认= 4.1.0）
PHP_NORMAL_READ - 读停在\ n或\r（在PHP <= 4.0.6默认）

Pour le paramètre PHP_NORMAL_READ, si le résultat de la réponse du serveur n'a pas n. Provoque socket_read() : impossible de lire depuis la prise

3. Programmation d'E/S simultanées de PHP

Texte original : http:// rango .swoole.com/archives/508

1) Blocage de la synchronisation multi-processus/multi-thread

Les premiers programmes côté serveur sont multi-processus et multi-thread Pour résoudre le problème de la concurrence

IO. Le modèle de processus est apparu le plus tôt et le concept de processus existe depuis la naissance du système Unix.
Les premiers programmes côté serveur sont généralement

Accepter

Un processus est créé lorsqu'un client se connecte, puis le processus enfant entre dans la boucle zone de blocage de synchronisation Interagissez avec les connexions client et envoyez et recevez des données de traitement. Le mode multi-threading est apparu plus tard, les threads sont plus légers que les processus et la pile mémoire est partagée entre les threads, donc l'interaction entre différents threads sont très faciles à mettre en œuvre. Par exemple, dans un programme tel qu'un salon de discussion, les connexions des clients peuvent interagir les unes avec les autres et les joueurs du salon de discussion peuvent envoyer des messages à n'importe quelle autre personne. Il est très simple à implémenter en mode multi-thread, et une connexion client peut être directement lue et écrite dans le thread. Le mode multi-processus nécessite l'utilisation de pipelines, de files d'attente de messages et de mémoire partagée pour réaliser une interaction de données, collectivement appelée communication inter-processus (IPC ), ce qui ne peut être réalisé qu’avec des technologies complexes. Exemple de code :

Multi-processus/Le processus du modèle de thread est

1. Créez un socket, liez le port du serveur (bind) , et écoutez sur le port (écouter), utilisez en PHP stream_socket_serverUne fonction peut compléter les 3 étapes ci-dessus, bien sûr, vous pouvez également utilisez php Les extensions sockets sont implémentées séparément.

2. entre dans la boucle while, bloquant dans accepter l'opération, en attendant l'arrivée de la connexion client. À ce moment-là, le programme entrera en état de veille jusqu'à ce qu'un nouveau client initie une connexion au serveur, et le système d'exploitation réveillera ce processus. La fonction accepter renvoie la socket

3. Le processus principal passe par fork(php : pcntl_fork) pour créer un processus enfant, utilisez pthread_create(php sous multi -modèle de filetage : new Thread) crée un fil de discussion enfant. Sauf indication contraire ci-dessous, le processus sera utilisé pour représenter le fil de discussion /.

4. Une fois que le processus enfant est créé avec succès, il entre dans la boucle while, bloquant dans recv(php: fread) est appelé et attend que le client envoie des données au serveur. Après avoir reçu les données, le programme serveur les traite puis utilise send (php : fwrite) envoie une réponse au client. Un service de connexion longue continuera à interagir avec le client, tandis qu'un service de connexion courte se fermera dès réception d'une réponse.

5. Lorsque la connexion client est fermée, le processus enfant se termine et détruit toutes les ressources. Le processus principal recyclera ce processus enfant.

Le plus gros problème avec ce modèle est que le processus / La création et la destruction de threads coûtent cher. Le modèle ci-dessus ne peut donc pas être appliqué à des programmes serveur très chargés. La version améliorée correspondante résout ce problème, qui est le modèle classique Leader-Follower.

Exemple de code :

Sa caractéristique est qu'il sera créé après le programme démarreN processus. Chaque processus enfant entre dans Accepter et attend que de nouvelles connexions arrivent. Lorsque le client se connecte au serveur, l'un des processus enfants sera réveillé, commencera à traiter la demande du client et n'acceptera plus de nouvelles connexions TCP. Lorsque cette connexion est fermée, le processus enfant sera libéré, entrera à nouveau Accepter et participera au traitement des nouvelles connexions.

L'avantage de ce modèle est qu'il permet de réutiliser totalement le procédé, sans consommation supplémentaire et avec un très bon rendement. De nombreux programmes serveur courants sont basés sur ce modèle, tels que Apache, PHP-FPM .

Le modèle multi-processus présente également certains inconvénients.

1. Ce modèle s'appuie fortement sur le nombre de processus pour résoudre les problèmes de concurrence. Une connexion client doit occuper un processus, le nombre de processus de travail présents et simultanés. capacités de traitement Autant qu'il y en a. Le système d'exploitation est limité dans le nombre de processus qu'il peut créer.

2. Le démarrage d'un grand nombre de processus entraînera une consommation supplémentaire de planification de processus. Lorsqu'il y a des centaines de processus, la consommation de planification de changement de contexte de processus peut représenter CPUmoins de 1 % Vous pouvez l'ignorer. Si des milliers, voire des dizaines de milliers de processus sont lancés, la consommation montera en flèche. La consommation de planification peut représenter des dizaines de pour cent de CPU ou même 100 % .

Il existe également certains scénarios que le modèle multi-processus ne peut pas résoudre, comme les programmes de chat instantané (IM), un serveur doit maintenir des dizaines de milliers voire des centaines de milliers ou des millions de connexions en même temps (le classique C10K problème), le modèle multi-processus est au-delà de mes capacités.

Il existe un autre scénario qui constitue également la faiblesse du modèle multi-processus. Généralement, le serveur Web démarre 100 processus si une requête consomme 100 ms, 100 les processus peuvent fournir 1000qps, cette capacité de traitement est plutôt bonne. Mais si la demande nécessite d'appeler l'interface Http du réseau externe, comme QQ , La connexion à Weibo prendra beaucoup de temps, une demande prend 10s. Ce processus 1 secondes ne peut gérer que 0,1 requêtes, 100 les processus ne peuvent atteindre que 10qps Cette capacité de traitement est trop faible.

Existe-t-il une technique capable de gérer toutes les concurrences IO au sein d'un processus ? La réponse est oui, il s’agit de la technologie de réutilisation IO.

IORéutilisation/Boucle d'événement /Asynchrone non bloquant

En faitIOL'histoire de la réutilisation est aussi longue que le multi-processus Linux propose depuis longtemps select<. 🎜> l'appel système peut maintenir 1024 connexions au sein d'un processus. Plus tard, l'appel système poll a été ajouté et certaines améliorations ont été apportées à poll. Résolu le problème de la limite 1024 et peut maintenir n'importe quel nombre de connexions. Mais select/poll Un autre problème est qu'il doit boucler pour détecter s'il y a des événements sur la connexion. Voici le problème, si le serveur a 100 millions de connexions, et qu'une seule connexion envoie des données au serveur à un certain moment, select/polldoit boucler 100 dix mille fois, dont seulement 1 fois sont des succès, et les 9910 000 9999 fois sont invalides, gaspillant les ressources CPU .

Jusqu'àLinux 2.6 le noyau fournit un nouveau epollSystème L'appel peut maintenir un nombre illimité de connexions sans interrogation, ce qui résout véritablement le problème C10K. De nos jours, divers programmes de serveur IO asynchrones à haute concurrence sont basés sur epoll Implémentés, tels que Nginx, Node.js, Erlang, Golang. Un programme à processus unique et à thread unique comme Node.js peut gérer plus de 1 Des millionsTCP connexions, tout cela grâce à la technologie epoll.

IORéutilisez des programmes asynchrones non bloquants à l'aide du classique Reactor Modèle, RéacteurComme son nom l'indique, cela signifie réacteur Il ne traite aucun envoi et réception de données. Il ne peut surveiller que les changements d'événements d'un socket handle.

RéacteurOui4 opérations principales :

1. ajouterAjouter une priseécouter réacteur, peut être écouter socket peut également créer le clientsocket, ou un tube, eventfd , signaux, etc.

2. setModifier l'écoute d'événement, vous pouvez définir le type d'écoute, tel que lisible, inscriptible. Lisible et facile à comprendre, pour écouter socket signifie que lorsqu'une nouvelle connexion client arrive, elle doit accepter. Pour que les connexions client reçoivent des données, recv est requis. Les événements inscriptibles sont un peu plus difficiles à comprendre. Un SOCKET possède une zone de cache. Si vous souhaitez vous connecter au client, envoyez 2M<🎜. >< Les données de 🎜> ne peuvent pas être envoyées en une seule fois. Par défaut, la zone de cache TCP du système d'exploitation n'a que . 256K. Vous ne pouvez envoyer 256K qu'une fois le cache plein, envoyer<. 🎜> Renverra l'erreur EAGAIN. À ce stade, vous devez surveiller les événements inscriptibles. En programmation asynchrone pure, vous devez surveiller les événements inscriptibles pour vous assurer que l'opération envoyer est totalement non bloquante. .

3. del

   du réacteurSupprimé de, ne plus écouter les événements

4. rappel est la logique de traitement correspondante après que l'événement se produit, généralement dans ajouter/définir est formulé. Le langage C est implémenté avec des pointeurs de fonctions, JS peut utiliser des fonctions anonymes, PHPVous pouvez utiliser des fonctions anonymes, des tableaux de méthodes d'objet et des noms de fonctions de chaîne.

Reactor n'est qu'un générateur d'événements, en fait socket gère les opérations, telles que se connecter/accepter, envoyer/recv, fermer est en rappel Terminé en . Pour un codage spécifique, veuillez vous référer au pseudocode suivant :

RéacteurLe modèle peut également être utilisé avec multi-processus, la combinaison de plusieurs threads peut non seulement obtenir un IO asynchrone non bloquant, mais également profiter de plusieurs cœurs. Les programmes de serveur asynchrone populaires actuels sont tous de cette manière : tels que

• Nginx : multi-processus Reactor

• Nginx+Lua : Multi-processusRéacteur+Coroutine

• Golang : Single ThreadReactor+Coroutine multi-thread

• Swoole：多线程Reactor+多进程Worker

4. PHP socket内部源码

从PHP内部源码来看，PHP提供的socket编程是在socket，bind,listen等函数外添加了一个层，让其更加简单和方便调用。但是一些业务逻辑的程序还是需要程序员自己去实现。
下面我们以socket_create的源码实现来说明PHP的内部实现。
前面我们有说到php的socket是以扩展的方式实现的。在源码的ext目录，我们找到sockets目录。这个目录存放了PHP对于socket的实现。直接搜索PHP_FUNCTION(socket_create)，在sockets.c文件中找到了此函数的实现。如下所示代码：

/* {{{ proto resource socket_create(int domain, int type, int protocol) U
   Creates an endpoint for communication in the domain specified by domain, of type specified by type */
PHP_FUNCTION(socket_create)
{
        long            arg1, arg2, arg3;
        php_socket      *php_sock = (php_socket*)emalloc(sizeof(php_socket));
 
        if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &arg1, &arg2, &arg3) == FAILURE) {
                efree(php_sock);
                return;
        }
 
        if (arg1 != AF_UNIX
#if HAVE_IPV6
                && arg1 != AF_INET6
#endif
                && arg1 != AF_INET) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid socket domain [%ld] specified for argument 1, assuming AF_INET", arg1);
                arg1 = AF_INET;
        }
 
        if (arg2 > 10) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid socket type [%ld] specified for argument 2, assuming SOCK_STREAM", arg2);
                arg2 = SOCK_STREAM;
        }
 
        php_sock->bsd_socket = socket(arg1, arg2, arg3);
        php_sock->type = arg1;
 
        if (IS_INVALID_SOCKET(php_sock)) {
                SOCKETS_G(last_error) = errno;
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to create socket [%d]: %s", errno, php_strerror(errno TSRMLS_CC));
                efree(php_sock);
                RETURN_FALSE;
        }
 
        php_sock->error = 0;
        php_sock->blocking = 1;
                                                                                                                                           1257,1-8      61%
        ZEND_REGISTER_RESOURCE(return_value, php_sock, le_socket);
}
/* }}} */

Zend API实际对c函数socket做了包装，供PHP使用。 而在c的socket编程中，我们使用如下方式初始化socket。

//初始化Socket  
    if( (socket_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ){  
         printf("create socket error: %s(errno: %d)\n",strerror(errno),errno);  
         exit(0);  
    }

5. socket函数

Nom de la fonction Description
socket_accept() accepte une connexion Socket
socket_bind() lie le socket à une adresse IP et un port
socket_clear_error () Effacer l'erreur de socket ou le dernier code d'erreur
socket_close() Fermer une ressource socket
socket_connect() Démarrer une connexion socket
socket_create_listen () ouvre une socket en écoute sur le port spécifié
socket_create_pair() génère une paire de sockets indifférenciées dans un tableau
socket_create() génère une socket , équivalent à générer une structure de données socket
socket_get_option() pour obtenir l'option socket
socket_getpeername() pour obtenir l'adresse IP d'un hôte similaire distant
socket_getsockname() Obtenez l'adresse IP du socket local
socket_iovec_add() Ajoutez un nouveau vecteur à un tableau scatter/agrégat
socket_iovec_alloc() Cette fonction crée Une structure de données iovec capable d'envoyer, de recevoir, de lire et d'écrire
socket_iovec_delete() supprime un iovec alloué
socket_iovec_fetch() renvoie les données de la ressource iovec spécifiée
socket_iovec_fetch() renvoie les données de la ressource iovec spécifiée
socket_iovec_free() libère une ressource iovec
socket_iovec_set() définit la nouvelle valeur des données iovec
socket_last_error() obtient la dernière erreur code de la socket actuelle
<🎜>socket_listen() écoute toutes les connexions de la socket spécifiée <🎜><🎜>socket_read() 读取指定长度的数据
socket_readv() 读取从分散/聚合数组过来的数据
socket_recv() 从socket里结束数据到缓存
socket_recvfrom() 接受数据从指定的socket，如果没有指定则默认当前socket
socket_recvmsg() 从iovec里接受消息
socket_select() 多路选择
socket_send() 这个函数发送数据到已连接的socket

socket_sendmsg() 发送消息到socket
socket_sendto() 发送消息到指定地址的socket
socket_set_block() 在socket里设置为块模式
socket_set_nonblock() socket里设置为非块模式
socket_set_option() 设置socket选项
socket_shutdown() 这个函数允许你关闭读、写、或指定的socket
socket_strerror() 返回指定错误号的周详错误
socket_write() 写数据到socket缓存
socket_writev() 写数据到分散/聚合数组

6. PHP Socket模拟请求

我们使用stream_socket来模拟：

/**
 * 
 * @param $data= array=array('key'=>value)
 */
function post_contents($data = array()) {
    $post = $data ? http_build_query($data) : '';
    $header = "POST /test/ HTTP/1.1" . "\n";
    $header .= "User-Agent: Mozilla/4.0+(compatible;+MSIE+6.0;+Windows+NT+5.1;+SV1)" . "\n";
    $header .= "Host: localhost" . "\n";
    $header .= "Accept: */*" . "\n";
    $header .= "Referer: http://localhost/test/" . "\n";
    $header .= "Content-Length: ". strlen($post) . "\n";
    $header .= "Content-Type: application/x-www-form-urlencoded" . "\n";
    $header .= "\r\n";
    $ddd = $header . $post;
    $fp = stream_socket_client("tcp://localhost:80", $errno, $errstr, 30);
    $response = '';
    if (!$fp) {
        echo "$errstr ($errno)<br />\n";
    } else {
        fwrite($fp, $ddd);
        $i = 1;
        while ( !feof($fp) ) {
            $r = fgets($fp, 1024);
            $response .= $r;
            //处理这一行
        }
    }
    fclose($fp);
    return $response;
}

注意，以上程序可能会进入死循环；

这个PHP的feof($fp) 需要注意的地方了，我们来分析为什么进入死循环。

        while ( !feof($fp) ) {
            $r = fgets($fp, 1024);
            $response .= $r;
        }

实际上，feof是可靠的，但是结合fgets函数一块使用的时候，必须要小心了。一个常见的做法是：

$fp = fopen("myfile.txt", "r");
while (!feof($fp)) {
   $current_line = fgets($fp);
   //对结果做进一步处理,防止进入死循环
}

当处理纯文本的时候，fgets获取最后一行字符后，foef函数返回的结果并不是TRUE。实际的运算过程如下：

 1) while（）继续循环。

 2) fgets 获取倒数第二行的字符串

 3) feof返回false，进入下一次循环

 4）fgets获取最后一行数据

 5)  一旦fegets函数被调用，feof函数仍然返回的是false。所以继续执行循环

 6) fget试图获取另外一行，但实际结果是空的。实际代码没有意识到这一点，试图处理另外根本不存在的一行，但fgets被调用了，feof放回的结果仍然是false

 7)    .....

8) 进入死循环

相关推荐：

PHP Socket编程起步

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!