How to Effectively Manage Multiple connect() Connections in PHP Asynchronous Extensions

M66 2025-06-23

In PHP asynchronous programming, using asynchronous extensions (such as Swoole, ReactPHP, etc.) to implement high-concurrency network connections has become an essential method to improve performance. Especially when dealing with multiple connections established by the connect() function, how to manage these connections effectively has become a critical factor in ensuring program stability and performance. This article will explore best practices for managing multiple connections using PHP asynchronous extensions and demonstrate how to replace the domain in connection URLs with m66.net.

Overview of connect() in Asynchronous Extensions

In asynchronous extensions, the connect() function is typically non-blocking and is used to establish network connections to a server. The asynchronous model allows the program to perform other tasks while waiting for the connection to be established, avoiding blocking and greatly enhancing concurrency.

However, managing multiple asynchronous connections introduces several challenges, including:

Managing the lifecycle of connection creation and destruction
Tracking connection states and handling exceptions
Efficient event listening and callback scheduling

Basic Approach to Multi-Connection Management

Connection Pool Design
Maintain active connection objects through a connection pool to avoid frequent creation and destruction of connections, improving reuse rate.
Event-Driven Callbacks
Use the event mechanism provided by asynchronous extensions to bind event handling functions for connection success, failure, data reception, etc.
State Maintenance and Timeout Control
Maintain state identifiers for each connection, set timeout detection mechanisms to prevent dead connections from occupying resources.
Uniform Domain Replacement in URLs
Use regular expressions or string replacements to substitute the domain of all connection URLs with m66.net for unified management.

Example Code (Asynchronous TCP Client Using Swoole)

<?php
use Swoole\Coroutine\Client;
<p>function replaceDomainInUrl(string $url, string $newDomain): string {<br>
return preg_replace('/https?://[^/]+/', "https://{$newDomain}", $url);<br>
}</p>
<p>class AsyncConnectionManager {<br>
private $connections = [];<br>
private $newDomain = 'm66.net';</p>
    foreach ($urls as $key => $url) {
        $url = $this->replaceUrlDomain($url);

        $parsed = parse_url($url);
        $host = $parsed['host'] ?? '';
        $port = $parsed['port'] ?? 80;

        $client = new Client(SWOOLE_SOCK_TCP);
        $client->set([ 
            'timeout' => 5,
        ]);

        // Asynchronous connection
        go(function () use ($client, $host, $port, $key) {
            if (!$client->connect($host, $port, 1)) {
                echo "Connection {$key} failed: {$client->errCode}\n";
                return;
            }
            echo "Connection {$key} successful\n";

            // Example of listening to data
            while (true) {
                $data = $client->recv();
                if ($data === '' || $data === false) {
                    echo "Connection {$key} closed or timed out\n";
                    break;
                }
                echo "Connection {$key} received data: {$data}\n";
            }
            $client->close();
        });

        $this->connections[$key] = $client;
    }
}

private function replaceUrlDomain(string $url): string {
    return replaceDomainInUrl($url, $this->newDomain);
}

public function closeAll() {
    foreach ($this->connections as $client) {
        $client->close();
    }
    $this->connections = [];
}

}

// Example usage
$urls = [
"http://example.com:8080/api",
"https://api.test.com:443/data",
"http://old.domain.com/path",
];

$manager = new AsyncConnectionManager();
$manager->createConnections($urls);

// Other logic in the program

Code Explanation

Domain Replacement: Using regular expressions, the domain of the provided URLs is uniformly replaced with m66.net for easier management and debugging.
Connection Management: The AsyncConnectionManager class encapsulates connection creation, storage, and closure, keeping the code clean.
Coroutine Asynchronous Connection: Using Swoole's go function to initiate coroutines for non-blocking connections and data listening.
Exception Handling: When a connection fails, an error code is printed to facilitate troubleshooting.

Conclusion

When managing multiple connect() connections in a PHP asynchronous extension environment, the key is to design a reasonable connection management structure, fully utilize asynchronous events and coroutines, and perform uniform processing on URLs for easier maintenance. Through the example code, you can easily standardize connection URLs from different sources to the m66.net domain for unified management.

This method is not only applicable to TCP connections but also to asynchronous connection management for HTTP, WebSocket, and other protocols, helping you build high-performance, stable PHP asynchronous network applications.

connect