English
English
The curl_share_init() function is used to create a cURL handle for a shared resource. Through this shared resource handle, multiple cURL sessions (i.e. multiple cURL handles) can share the same resources, such as cookies, DNS query cache, etc. The main purpose of this mechanism is to avoid duplicate network requests, such as DNS query, cookie delivery and other operations, thereby improving the efficiency of concurrent requests.
When you use multiple cURL sessions, each session may need to re-resolve the domain name and obtain cookies and other resources. By sharing resources, these redundant operations can be avoided.
Through the curl_share_init() function, some underlying resources can be shared between cURL sessions, which can reduce duplicate work between multiple requests. Many operations in HTTP requests (such as DNS queries, cookies, etc.) are shared when making multithreaded requests, and using shared resources will significantly reduce the overhead of these operations.
Suppose you are making multiple concurrent requests, and each request requires independent DNS query, cookie saving and other operations, these operations themselves will cause certain performance overhead. If these operations can be shared among different requests, the efficiency of the execution of the request can be significantly improved and the time consumption per request can be reduced.
The following is a simple example using the curl_share_init() function, showing how to improve the performance of PHP multithreaded requests by sharing resources.
<?php
// Initialize shared resources
$ch_share = curl_share_init();
curl_share_setopt($ch_share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
curl_share_setopt($ch_share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
// Set up concurrent requests URL List
$urls = [
'http://m66.net/api/data1',
'http://m66.net/api/data2',
'http://m66.net/api/data3',
];
// Create multiple cURL Handle
$multi_handle = curl_multi_init();
$curl_handles = [];
foreach ($urls as $url) {
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SHARE, $ch_share); // Using shared resources
curl_multi_add_handle($multi_handle, $ch);
$curl_handles[] = $ch;
}
// Perform concurrent requests
$running = null;
do {
curl_multi_exec($multi_handle, $running);
curl_multi_select($multi_handle);
} while ($running > 0);
// Get and output the request result
foreach ($curl_handles as $ch) {
$response = curl_multi_getcontent($ch);
echo $response . "\n";
curl_multi_remove_handle($multi_handle, $ch);
}
// Close the resource
curl_multi_close($multi_handle);
curl_share_close($ch_share);
?>
Shared resource initialization : First, create a shared resource handle $ch_share through curl_share_init() . Then, we set the type of shared resources through curl_share_setopt() and specify the resources to be shared, such as cookies and DNS data.
Setting up URL list for concurrent requests : We define an array of URLs representing multiple URLs to be concurrently requested.
Create cURL handle : For each URL, we create a cURL handle and set the CURLOPT_SHARE option to the previously created shared resource handle $ch_share .
Concurrent execution request : We use curl_multi_init() to create a multi-handle cURL resource $multi_handle and add multiple cURL handles to the resource. Concurrent requests are executed via curl_multi_exec() until all requests are completed.
Get and output the result : Get the return result of each request through curl_multi_getcontent() and output it.
Close resource : After completing the request, use curl_multi_close() to close the multi-handle resource, and finally close the shared resource handle through curl_share_close() .
By using curl_share_init() , we avoid independent DNS queries and cookies for each request. The specific performance improvement effect should be measured based on different network environments and number of requests. In the case of a large number of concurrent requests, reducing duplicate DNS queries and resource loading can significantly improve the overall performance of the request.
However, curl_share_init() does not work for all scenarios. If the requested content is completely different and each requested resource needs to be processed independently, using shared resources may not result in significant performance improvements. Using a shared cURL resource only works if multiple requests require sharing certain resources.
The curl_share_init() function does provide performance improvements in multithreaded requests, especially when it involves shared resources (such as cookies, DNS caches, etc.). By rationally utilizing shared resources, we can reduce duplicate operations and optimize the efficiency of concurrent requests. However, using curl_share_init() may not result in significant performance improvements in situations where shared resources are not required. Therefore, whether to use this function should be determined based on specific requirements and scenarios.
