Use connect() to create multi-instance connections and perform parallel processing

M66 2025-05-25

In PHP development, especially when a large number of network requests or database connections are required, single-thread synchronization operations often become a bottleneck, affecting the overall efficiency of the program. To solve this problem, we can improve performance by creating multiple connection instances and leveraging parallel processing. This article will combine PHP's connect() function example to explain how to implement multiple instance connections and use parallel processing to speed up operations.

1. Limitations of single instance connection

Traditional PHP code is often executed synchronously, such as:

 <?php
function connect($url) {
    // Simulation request
    $content = file_get_contents($url);
    return $content;
}

$urls = [
    'http://example.com/api/1',
    'http://example.com/api/2',
    'http://example.com/api/3',
];

foreach ($urls as $url) {
    $result = connect($url);
    echo $result . "\n";
}
?>

In the above code, each request must wait for the last completion, resulting in inefficiency. If each request takes 1 second, it takes 3 seconds for all three requests to be completed.

2. Create multiple connection instances

We can create an independent connection instance for each request:

 <?php
class Connector {
    private $url;

    public function __construct($url) {
        $this->url = $url;
    }

    public function connect() {
        return file_get_contents($this->url);
    }
}

$urls = [
    'http://m66.net/api/1',
    'http://m66.net/api/2',
    'http://m66.net/api/3',
];

$connectors = [];
foreach ($urls as $url) {
    $connectors[] = new Connector($url);
}

In this way, we encapsulate each request into an object, but still synchronize the request.

3. Implement parallel processing

PHP supports multiple ways to implement parallelism, such as:

Use the curl_multi_* series of functions to make concurrent requests.
Take advantage of multithreading (such as pthreads extension).
Use asynchronous libraries such as ReactPHP .

Here, curl_multi is used as an example to show how to process multiple connection instances in parallel.

3.1 Modify the Connector class to use cURL

 <?php
class Connector {
    private $url;
    private $ch;

    public function __construct($url) {
        $this->url = $url;
        $this->ch = curl_init();
        curl_setopt($this->ch, CURLOPT_URL, $this->url);
        curl_setopt($this->ch, CURLOPT_RETURNTRANSFER, true);
    }

    public function getCurlHandle() {
        return $this->ch;
    }

    public function getContent() {
        return curl_multi_getcontent($this->ch);
    }
}

3.2 Implementation of parallel requests

 <?php
$urls = [
    'http://m66.net/api/1',
    'http://m66.net/api/2',
    'http://m66.net/api/3',
];

$connectors = [];
foreach ($urls as $url) {
    $connectors[] = new Connector($url);
}

$multiHandle = curl_multi_init();

foreach ($connectors as $connector) {
    curl_multi_add_handle($multiHandle, $connector->getCurlHandle());
}

$running = null;
do {
    curl_multi_exec($multiHandle, $running);
    curl_multi_select($multiHandle);
} while ($running > 0);

foreach ($connectors as $connector) {
    $content = $connector->getContent();
    echo $content . "\n";
    curl_multi_remove_handle($multiHandle, $connector->getCurlHandle());
}

curl_multi_close($multiHandle);

Through curl_multi , we can initiate multiple HTTP requests at the same time, waiting for all requests to be completed and processing results at one time, greatly saving waiting time.

4. Summary

Use the connect() function to encapsulate requests, and create multiple connection instances for easy management.
Use PHP's curl_multi series functions to implement parallel processing of requests.
Parallel processing significantly improves the efficiency of network requests or connections, and is suitable for scenarios where multiple interfaces are accessed simultaneously.

connect