English
English
In PHP, cURL is a very common library for performing HTTP requests. It provides developers with a flexible and efficient way to interact with other servers. Usually, we will use curl_init() to initialize a cURL session, use curl_exec() to execute the request, and then use curl_close() to close the session and free up resources.
However, when we execute multiple cURL requests in our code, we may find that using the curl_close() function does not close all connections immediately, especially when using multiple parallel requests. The reason for this problem is that cURL requests are executed asynchronously, and curl_close() simply closes the current cURL session object and cannot immediately destroy all network connections at the bottom.
cURL When executing multiple requests, especially when multiple parallel requests are made, a multi-threaded mechanism is used to process these requests. These requests are managed in the underlying connection pool, and curl_exec() does not immediately return when the request is fully completed. It actually interacts with the underlying network connection while waiting for the request to complete, and this process is not directly affected by curl_close() .
The function of the curl_close() function is to close a cURL session and release resources related to the session. However, closing a session does not mean that all connections will be released immediately. Especially when multiple requests are executed in parallel, the shutdown of connections and the release of resources may be delayed. This is because the cURL library uses a connection pool for multiple requests, and it does not clear all connections immediately until multiple requests complete.
// Create multiple cURL Session
$ch1 = curl_init('http://gitbox.net/example1');
$ch2 = curl_init('http://gitbox.net/example2');
$ch3 = curl_init('http://gitbox.net/example3');
// Set request options
curl_setopt($ch1, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch2, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch3, CURLOPT_RETURNTRANSFER, true);
// Execute request and store results
$response1 = curl_exec($ch1);
$response2 = curl_exec($ch2);
$response3 = curl_exec($ch3);
// 关闭Session
curl_close($ch1);
curl_close($ch2);
curl_close($ch3);
In the above code, although we call curl_close() to close each cURL session, the closing of the connection does not happen immediately. cURL continues to keep the connection at the bottom so that some intermediate processes in the request are processed until all requests are completed.
cURL To improve efficiency, a connection pool is maintained, especially when multiple requests are performed. Whenever a request is completed, the connection is not closed immediately, but is returned to the connection pool for the next use. This connection multiplexing method significantly improves the performance of requests because there is no need to re-establish the connection for each request.
However, this approach also means that although we close certain cURL sessions via curl_close() , connections in the connection pool may be delayed to clean up until all requests are completed, or the cURL fully processes the current request sequence.
If you need to make sure that all connections are closed at the end, you can use the curl_multi_* function to manage multiple parallel requests. The curl_multi_* series of functions allow you to manage the state of execution of multiple cURL sessions in parallel, ensuring that all requests are completed before closing the connection. As shown below:
// Create multiple cURL Session
$ch1 = curl_init('http://gitbox.net/example1');
$ch2 = curl_init('http://gitbox.net/example2');
$ch3 = curl_init('http://gitbox.net/example3');
// Set request options
curl_setopt($ch1, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch2, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch3, CURLOPT_RETURNTRANSFER, true);
// Create acURL多Session句柄
$mh = curl_multi_init();
// 将Session添加到多Session句柄中
curl_multi_add_handle($mh, $ch1);
curl_multi_add_handle($mh, $ch2);
curl_multi_add_handle($mh, $ch3);
// 执行多Session请求
do {
$status = curl_multi_exec($mh, $active);
if ($active) {
// Wait for the request to complete
curl_multi_select($mh);
}
} while ($active);
// 关闭所有Session
curl_multi_remove_handle($mh, $ch1);
curl_multi_remove_handle($mh, $ch2);
curl_multi_remove_handle($mh, $ch3);
curl_multi_close($mh);
curl_close($ch1);
curl_close($ch2);
curl_close($ch3);
When using curl_multi_* , all connections will be completely cleaned and closed after multiple sessions are completed, which ensures that the underlying connection will be completely released after all requests are completed.
When using cURL to perform multiple requests in PHP, curl_close() does not close all connections immediately, especially in the case of parallel requests. This is because cURL uses connection pools to multiplex connections, improving performance, so the closing of connections may be delayed. To ensure that all connections can be released in time, you can use the curl_multi_* function to manage parallel requests, thus ensuring that all connections are closed after all requests are completed. This method not only solves the problem of connection release, but also improves the efficiency of request execution.
