I wanted to learn a bit more about concurrency and network programming, so I built two TCP socket servers in PHP as a coding challenge. It’s a practical way to practice and get a grip on managing multiple connections at once. I’m not going for anything complex—just experimenting and picking up the basics step by step. The code can be found in my repository: https://github.com/lzag/webserver
I found it quite useful to go through the Beej's guide to network programming to understand the inner workings of sockets programming and have a better idea of how the PHP wrappers work underneath. I added comments in the code linking to relevant sections of the guide. Another helpful resource is Mastering Swoole PHP, which explains concurrency concepts and includes some network programming examples.
To run the server I built a Docker image with the necessary extensions:
PHP Parallel extension
PHP Sockets extension
The former contains PHP wrappers around socket system calls and the latter is to achieve parallel execution.
I also added a Locust container to the composee file with some basic configuration that allows me to test the performance of the server.
There are 2 versions of the server - single and multi-threaded.
Single threaded server
First, I’m building a non-blocking single threaded socket server in PHP. I’m setting up a TCP server that listens on port 9090, manages multiple client connections concurrently, and handles incoming data asynchronously. This setup lets me explore concurrency concepts like non-blocking I/O and signal handling, managing multiple clients without relying on threads or forks.
I create a TCP socket with socket_create(), using IPv4 (AF_INET) and a streaming protocol (SOCK_STREAM).
$socket = socket_create(AF_INET, SOCK_STREAM, 0);I bind the socket to 0.0.0.0 on port 9090, allowing connections from any interface. Any error can be retrieved using a combination of socket_last_erorr and socket_strerorr.
if (socket_bind($socket, '0.0.0.0', 9090) === false) {
echo "socket_bind() failed: reason: " . socket_strerror(socket_last_error($socket)) . "\n";
exit;
}I set the socket to listen for incoming connections using socket_listen().
if (socket_listen($socket) === false) {
echo "socket_listen() failed: reason: " . socket_strerror(socket_last_error($socket)) . "\n";
exit;
}I switch the socket to non-blocking mode with socket_set_nonblock() so it doesn’t hang on I/O operations and maintain an array of clients to track all active client sockets.
socket_set_nonblock($socket);
$clients = [];I register a SIGINT signal handler with pcntl_signal() to shut down gracefully when I interrupt it (e.g., with Ctrl+C). Normally Docker compose would send SIGTERM, but I configure it to send SIGINT like the Linux command line.
pcntl_signal(SIGINT, function () use (&$running) {
$running = false;
echo "Caught signal, shutting down...\n";
});I run an infinite loop until I stop it:
I check for new connections with socket_accept() and add them to my $clients array. I loop through connected clients, reading their data with socket_read() in non-blocking mode. I process their input, sending back an HTTP 200 OK response, and close their connection if they send "quit. I dispatch pending signals with pcntl_signal_dispatch() and add a tiny delay (usleep(1)) to avoid overloading the CPU.
while ($running) {
if ($conn = socket_accept($socket)) {
if ($conn !== false) {
echo "New connection is accepted\n";
socket_set_nonblock($conn);
$clients[] = $conn;
$id = sizeof($clients) - 1;
echo "Connection #[$id] is connected\n";
}
}
if (count($clients)) {
foreach ($clients as $id => $conn) {
if ($input = socket_read($conn, 512)) {
$input = trim($input);
echo "Connection #[$id] input: $input\n";
$ack = "HTTP/1.0 200 OK\r\nContent-Length: 0\r\n\r\n";
socket_write($conn, $ack, strlen($ack));
if ($input == 'quit') {
socket_close($conn);
unset($clients[$id]);
echo "Connection #[$id] is disconnected\n";
}
}
}
}
pcntl_signal_dispatch();
usleep(1);
}When I shut it down, I close all active client connections in $clients and terminate the listening socket.
Multi-threaded server
In the second version I’ve upgraded my original non-blocking socket server to use multiple threads with PHP’s parallel extension. While the core setup (listening on port 9090, non-blocking I/O, and signal handling) remains similar, I’ve introduced significant changes to handle requests concurrently with a thread pool and processing of HTTP-like inputs.
I create a thread pool with 10 threads using parallel\Runtime to process client requests in parallel, replacing the single-threaded approach of the first version.
$poolSize = 10;
$pool = [];
for ($i = 0; $i < $poolSize; $i++) {
$pool[] = new Runtime();
}I define a closure to handle HTTP requests, parsing the method, path, and protocol, serving files from /var/www/html, and returning formatted HTTP responses (e.g., 200 OK, 404 Not Found), instead of just echoing input and sending a static 200 OK. Sleep is there to simulate processing time.
$processRequest = function ($input): string {
sleep(1);
$docRoot = "/var/www/html";
@list($method, $path, $protocol) = explode(' ', $input, 3);
if (!isset($method) || !isset($path) || !isset($protocol)) {
return "HTTP/1.1 400 Bad Request\r\n\r\n";
}
if ($path == '/') {
$path = $docRoot . "/" . "page.html";
} else {
$path = $docRoot . $path;
}
if (!file_exists($path)) {
$response = "HTTP/1.1 404 Not Found\r\nRequested path: $path\r\n\r\n";
} else {
$responseBody = file_get_contents($path);
$response = "HTTP/1.1 200 OK\r\n";
$response .= "Content-Type: text/html\r\n";
$response .= "Content-Length: " . strlen($responseBody);
$response .= "\r\n\r\n";
$response .= $responseBody;
$response .= "\r\n\r\n";
}
return $response;
};I limit the number of concurrent clients to 100, rejecting new connections with a 503 Service Unavailable response if the limit is reached, unlike the first version which accepted unlimited clients.
if (count($clients) >= 100) {
$refusal = "HTTP/1.1 503 Service Unavailable\r\nContent-Length: 20\r\n\r\nServer is full, sorry";
socket_write($incoming_conn, $refusal, strlen($refusal));
socket_close($incoming_conn);
echo "Refused a connection - client limit (100) reached\n";
} else {
echo "Connection is accepted\n";
$clients[] = $incoming_conn;
}I replace the simple polling loop with socket_select() to efficiently monitor multiple sockets (the server socket and clients) for readability, improving scalability over the first version’s manual checks.
$readfds = array_merge($clients, [$socket]);
$writefds = NULL;
$errorfds = [];
$select = socket_select($readfds, $writefds, $errorfds, 0, 1000);I offload request processing to the thread pool by submitting tasks to the thread pool with run(), storing the results in an array, instead of handling requests inline like in the first version.
if ($input = socket_read($conn, 8192)) {
$input = trim($input);
$futures[$connkey] = $pool[array_rand($pool)]->run($processRequest, [$input]);
}I check completed futures in a separate loop, write their responses to clients, and close connections immediately after, unlike the first version where I kept connections open until a "quit" command.
foreach ($futures as $key => $future) {
if ($future->done()) {
$response = $future->value();
$conn = $clients[$key];
echo "Conn #[$key] writing response...\n";
socket_write($conn, $response, strlen($response));
unset($futures[$key]);
socket_close($conn);
unset($clients[$key]);
}
}I modify the main loop to continue running until both $running is false and all $futures are resolved, ensuring all threaded tasks complete before shutdown, unlike the first version which stopped immediately.
while ($running || !empty($futures)) {
// ... (rest of the loop)
}These changes shift my server from a basic, single-threaded echo service to a multi-threaded, HTTP-capable server with connection limits and efficient I/O handling, leveraging parallelism for better performance.
Testing in Locust shows the difference in peformance: the first version only can achieve 1 RPS vs the other close to 10 RPS. In real life we would avoid blocking the tread, but for this simple exercise that's good enough.