PHP socket learning: take you to make a simple socket server

This article will take you to explore PHP sockets for the first time, and learn about sockets by making a simple socket server. I hope it will be helpful to you!

#The Chinese name of socket is called socket. This kind of thing is the "encapsulation" of TCP/IP. In reality, the network actually has only four layers. From top to bottom, they are the application layer, the transport layer, the network layer, and the data link layer. The most commonly used http protocol is a protocol belonging to the application layer, and socket can be simply and roughly understood as a thing of the transport layer. If it is still difficult to understand, then add tcp://218.221.11.23:9999 more roughly, do you see it? This is a tcp socket.

Socket gives us the ability to control the transport layer and network layer, thereby obtaining stronger performance and higher efficiency. Socket programming is the most commonly used and mature solution to solve high-concurrency network servers. Any server programmer should master socket programming related skills.

In PHP, there are two sets of functions that can control sockets. One is the socket_ series of functions, and the other is the stream_ series of functions. Socket_ is implemented by PHP directly copying the socket in C language, while stream_ is implemented by PHP using the concept of stream to encapsulate it. Let's use the socket_* series functions to simply start this series of articles.

First make the simplest socket server:

<?php
$host = &#39;0.0.0.0&#39;;
$port = 9999;
// 创建一个tcp socket
$listen_socket = socket_create( AF_INET, SOCK_STREAM, SOL_TCP );
// 将socket bind到IP：port上
socket_bind( $listen_socket, $host, $port );
// 开始监听socket
socket_listen( $listen_socket );
// 进入while循环，不用担心死循环死机，因为程序将会阻塞在下面的socket_accept()函数上
while( true ){
  // 此处将会阻塞住，一直到有客户端来连接服务器。阻塞状态的进程是不会占据CPU的
  // 所以你不用担心while循环会将机器拖垮，不会的 
  $connection_socket = socket_accept( $listen_socket );
  // 向客户端发送一个helloworld
  $msg = "helloworld\r\n";
  socket_write( $connection_socket, $msg, strlen( $msg ) );
  socket_close( $connection_socket );
}
socket_close( $listen_socket );

Save the file as server.php, and then execute php server.php to run it. We can use telnet on the client. Open another terminal and execute telnet 127.0.0.1 9999 and press Enter. The running results are as follows:

Briefly analyze the above code to explain the process of the tcp socket server:

• 1. First, according to Protocol family (or address family), socket type, and a specific protocol to create a socket.
• 2. Second, bind the socket created in the previous step to an ip:port.
• 3. Third, enable monitoring linten.
• 4. Fourth, make the server code enter an infinite loop without exiting. When there is no client connection, the program blocks on accept. It will execute downwards only when a connection comes in, and then loop again to provide services to the client. Provides persistent services.

In the above case, there are two big flaws:

• 1. Only one client can be served at a time. If the first client is being served, If a second client connects while the client is sending helloworld, then the second client must wait for a while.
• 2. It is easy to be attacked and cause denial of service.

After analyzing the above problems, I thought of the multi-process mentioned earlier. Then we can fork a child process to handle the client's request after accpet receives a request, so that when the accept After two clients, fork a child process to handle the request of the second client. Wouldn't the problem be solved? OK! Let’s demonstrate the code:

<?php
$host = &#39;0.0.0.0&#39;;
$port = 9999;
// 创建一个tcp socket
$listen_socket = socket_create( AF_INET, SOCK_STREAM, SOL_TCP );
// 将socket bind到IP：port上
socket_bind( $listen_socket, $host, $port );
// 开始监听socket
socket_listen( $listen_socket );
// 进入while循环，不用担心死循环死机，因为程序将会阻塞在下面的socket_accept()函数上
while( true ){
  // 此处将会阻塞住，一直到有客户端来连接服务器。阻塞状态的进程是不会占据CPU的
  // 所以你不用担心while循环会将机器拖垮，不会的 
  $connection_socket = socket_accept( $listen_socket );
  // 当accept了新的客户端连接后，就fork出一个子进程专门处理
  $pid = pcntl_fork();
  // 在子进程中处理当前连接的请求业务
  if( 0 == $pid ){
    // 向客户端发送一个helloworld
    $msg = "helloworld\r\n";
    socket_write( $connection_socket, $msg, strlen( $msg ) );
    // 休眠5秒钟，可以用来观察时候可以同时为多个客户端提供服务
    echo time().&#39; : a new client&#39;.PHP_EOL;
    sleep( 5 );
    socket_close( $connection_socket );
    exit;
  }
}
socket_close( $listen_socket );

Save the code as server.php, and then execute php server.php. The client still uses telnet 127.0.0.1 9999, but this time we open two terminals to execute telnet. It is important to observe that after the first client connects, the second client can also connect. The running results are as follows:

# By receiving the timestamp of the client request, you can see that the server can now serve N clients at the same time. But, then think about it, what if 10,000 clients come to request? At this time, the server will fork out 10,000 child processes to handle each client connection, which will kill people. Fork itself is a system call that wastes system resources. 10,000 forks are enough to cause the system to crash. Even if the system can withstand 1,000 forks, the 1,000 child processes that come out of the fork are enough to drink a pot of system memory. In the end, is it okay? The child process that is easy to fork out will be closed after processing the current client, and it will have to be forked again for the next request. This in itself is a waste and does not conform to the mainstream socialist values. If there is a malicious attack, the number of system forks will increase linearly until the system crashes.

So, we once again propose an enhanced solution. We can estimate the business volume, and then fork a fixed number of child processes when the service starts. Each child process is in an infinite loop and blocked on accept. When a client connection squeezes in, the customer request is processed. After the processing is completed, the connection is only closed but not destroyed, but continues to wait for the next client request. In this way, it not only avoids the huge waste of resources caused by repeated forks of the process, but also protects the system from crashing due to infinite forks through a fixed number of child processes.

<?php
$host = &#39;0.0.0.0&#39;;
$port = 9999;
// 创建一个tcp socket
$listen_socket = socket_create( AF_INET, SOCK_STREAM, SOL_TCP );
// 将socket bind到IP：port上
socket_bind( $listen_socket, $host, $port );
// 开始监听socket
socket_listen( $listen_socket );
// 给主进程换个名字
cli_set_process_title( &#39;phpserver master process&#39; );
// 按照数量fork出固定个数子进程
for( $i = 1; $i <= 10; $i++ ){
  $pid = pcntl_fork();
  if( 0 == $pid ){
    cli_set_process_title( &#39;phpserver worker process&#39; );
    while( true ){
      $conn_socket = socket_accept( $listen_socket );
      $msg = "helloworld\r\n";
      socket_write( $conn_socket, $msg, strlen( $msg ) );
      socket_close( $conn_socket );
    }
  }
}
// 主进程不可以退出，代码演示比较粗暴，为了不保证退出直接走while循环，休眠一秒钟
// 实际上，主进程真正该做的应该是收集子进程pid，监控各个子进程的状态等等
while( true ){
  sleep( 1 );
}
socket_close( $connection_socket );

After saving the file as server.php, execute php server.php, and then use ps -ef | grep phpserver | grep -v grep to see the server process status:

You can see that the master process exists. In addition, there are 10 sub-processes waiting for service. They can provide services to 10 clients at the same time. Let’s try it through telnet 127.0.0.1 9999. The running result is as follows:

Okay, PHP’s new journey series will start with a simple introduction. La! The next article will describe some more profound theoretical basics.

Recommended learning: "PHP Video Tutorial"

The above is the detailed content of PHP socket learning: take you to make a simple socket server. For more information, please follow other related articles on the PHP Chinese website!