CURL网络访问 多线程无法正常取到返回

20140706

单线程情况下正常，多线程取不到返回内容

admin

是不是 不支持多线程

20140706

admin 发表于 2025-1-3 13:59
是不是 不支持多线程

对，测过了，多线程跑不了，多线程下 只有最后一个会正常发送请求，按照网上例子，改了下初始化和清理，能跑多线程了，不太懂C，不知道会不会有其他问题

1. #include "module_curl2.h"
   
2. #include <mutex>  // 用于std::mutex
   
3. 
   
4. // 静态互斥锁，保护全局curl初始化和清理
   
5. static std::mutex curl_global_mutex;
   
6. 
   
7. CURL网络传输类2::CURL网络传输类2()
   
8. {
   
9.     m_RequstHeaderList = NULL;
   
10.     m_curl = NULL;
    
11.     m_form = NULL;
    
12. }
    
13. 
    
14. size_t CURL网络传输类2::write_data(void* contents, size_t size, size_t nmemb, void* userp)
    
15. {
    
16.     size_t realsize = size * nmemb;
    
17.     struct MemoryStruct* mem = (struct MemoryStruct*)userp;
    
18. 
    
19.     char* ptr = (char*)realloc(mem->memory, mem->size + realsize + 1);
    
20.     if (ptr == NULL) {
    
21.         /* out of memory! */
    
22.         printf("not enough memory (realloc returned NULL)\n");
    
23.         return 0;
    
24.     }
    
25. 
    
26.     mem->memory = ptr;
    
27.     memcpy(&(mem->memory[mem->size]), contents, realsize);
    
28.     mem->size += realsize;
    
29.     mem->memory[mem->size] = 0;
    
30. 
    
31.     return realsize;
    
32. }
    
33. 
    
34. size_t CURL网络传输类2::write_head(char* buffer, size_t size, size_t nitems, void* userp)
    
35. {
    
36.     size_t realsize = size * nitems;
    
37.     struct MemoryStruct* mem = (struct MemoryStruct*)userp;
    
38. 
    
39.     char* ptr = (char*)realloc(mem->memory, mem->size + realsize + 1);
    
40.     if (ptr == NULL) {
    
41.         /* out of memory! */
    
42.         printf("not enough memory (realloc returned NULL)\n");
    
43.         return 0;
    
44.     }
    
45. 
    
46.     mem->memory = ptr;
    
47.     memcpy(&(mem->memory[mem->size]), buffer, realsize);
    
48.     mem->size += realsize;
    
49.     mem->memory[mem->size] = 0;
    
50. 
    
51.     return realsize;
    
52. }
    
53. 
    
54. int CURL网络传输类2::全局初始化CURL() {
    
55.     std::lock_guard<std::mutex> lock(curl_global_mutex);
    
56.     static bool is_initialized = false;
    
57.     if (!is_initialized) {
    
58.         CURLcode ret = curl_global_init(CURL_GLOBAL_ALL);
    
59.         if (ret != CURLE_OK) {
    
60.             return (vint)ret;
    
61.         }
    
62.         is_initialized = true;
    
63.     }
    
64.     return CURLE_OK;
    
65. }
    
66. 
    
67. char* CURL网络传输类2::取版本() {
    
68.     char* ver = curl_version();
    
69.     return ver;
    
70. }
    
71. 
    
72. CURL* CURL网络传输类2::初始化CURL句柄() {
    
73.     ZeroMemory(m_szErrorBuffer, sizeof(m_szErrorBuffer));
    
74.     m_curl = curl_easy_init();
    
75.    
    
76.     // 每个线程使用独立的内存结构
    
77.     m_ResponsBody.memory = (char*)malloc(1);
    
78.     if (m_ResponsBody.memory != NULL) m_ResponsBody.memory[0] = (char)0;
    
79.     m_ResponsBody.size = 0;
    
80. 
    
81.     curl_easy_setopt(m_curl, CURLOPT_WRITEFUNCTION, write_data);
    
82.     curl_easy_setopt(m_curl, CURLOPT_WRITEDATA, (void*)&m_ResponsBody);
    
83. 
    
84.     m_ResponsHead.memory = (char*)malloc(1);
    
85.     if (m_ResponsHead.memory != NULL) m_ResponsHead.memory[0] = (char)0;
    
86.     m_ResponsHead.size = 0;
    
87. 
    
88.     curl_easy_setopt(m_curl, CURLOPT_HEADERFUNCTION, write_head);
    
89.     curl_easy_setopt(m_curl, CURLOPT_HEADERDATA, (void*)&m_ResponsHead);
    
90. 
    
91.     m_RequstHeaderList = NULL;
    
92.     curl_easy_setopt(m_curl, CURLOPT_ERRORBUFFER, m_szErrorBuffer);
    
93. 
    
94.     return m_curl;
    
95. }
    
96. 
    
97. void CURL网络传输类2::置地址(LPCSTR url) {
    
98.     curl_easy_setopt(m_curl, CURLOPT_URL, url);
    
99. }
    
100. 
     
101. void CURL网络传输类2::置代理(LPCSTR proxy) {
     
102.     curl_easy_setopt(m_curl, CURLOPT_PROXY, proxy);
     
103. }
     
104. 
     
105. void CURL网络传输类2::置文件(LPCSTR name, LPCSTR file) {
     
106.     struct curl_httppost* lastptr = NULL;
     
107.     curl_formadd(&m_form, &lastptr,
     
108.                      CURLFORM_COPYNAME, name,
     
109.                      CURLFORM_FILE, file,
     
110.                      CURLFORM_END);
     
111.     curl_easy_setopt(m_curl, CURLOPT_HTTPPOST, m_form);
     
112. }
     
113. 
     
114. void CURL网络传输类2::置POST数据(const char* data, long length)
     
115. {
     
116.     curl_easy_setopt(m_curl, CURLOPT_POSTFIELDS, data);
     
117.     curl_easy_setopt(m_curl, CURLOPT_POSTFIELDSIZE, length);
     
118. }
     
119. 
     
120. BOOL CURL网络传输类2::执行访问()
     
121. {
     
122.     if (m_RequstHeaderList != NULL) {
     
123.         curl_easy_setopt(m_curl, CURLOPT_HTTPHEADER, m_RequstHeaderList);
     
124.     }
     
125. 
     
126.     if (m_ResponsHead.memory != NULL)
     
127.     {
     
128.         free(m_ResponsHead.memory);
     
129.     }
     
130. 
     
131.     if (m_ResponsBody.memory != NULL)
     
132.     {
     
133.         free(m_ResponsBody.memory);
     
134.     }
     
135. 
     
136.     // 每个线程使用独立的内存结构
     
137.     m_ResponsBody.memory = (char*)malloc(1);
     
138.     if (m_ResponsBody.memory != NULL) m_ResponsBody.memory[0] = (char)0;
     
139.     m_ResponsBody.size = 0;
     
140. 
     
141.     m_ResponsHead.memory = (char*)malloc(1);
     
142.     if (m_ResponsHead.memory != NULL) m_ResponsHead.memory[0] = (char)0;
     
143.     m_ResponsHead.size = 0;
     
144. 
     
145.     BOOL res = (curl_easy_perform(m_curl) == CURLE_OK) ? TRUE : FALSE;
     
146.     return res;
     
147. }
     
148. 
     
149. void CURL网络传输类2::清理() {
     
150.     curl_easy_cleanup(m_curl);
     
151.     curl_formfree(m_form);
     
152. 
     
153.     if (m_ResponsHead.memory != NULL)
     
154.     {
     
155.         free(m_ResponsHead.memory);
     
156.     }
     
157.     if (m_ResponsBody.memory != NULL)  
     
158.     {
     
159.         free(m_ResponsBody.memory);
     
160.     }
     
161. }
     
162. 
     
163. void CURL网络传输类2::置UserAgent(LPCSTR m_UserAgent)
     
164. {
     
165.     if (m_curl == NULL) {
     
166.         return;
     
167.     }
     
168.     curl_easy_setopt(m_curl, CURLOPT_USERAGENT, m_UserAgent);
     
169. }
     
170. 
     
171. void CURL网络传输类2::置Encoding(LPCSTR m_Encoding)
     
172. {
     
173.     if (m_curl == NULL) {
     
174.         return;
     
175.     }
     
176.     curl_easy_setopt(m_curl, CURLOPT_ACCEPT_ENCODING, m_Encoding);
     
177. }
     
178. 
     
179. void CURL网络传输类2::置Referer(LPCSTR m_Referer)
     
180. {
     
181.     if (m_curl == NULL) {
     
182.         return;
     
183.     }
     
184.     curl_easy_setopt(m_curl, CURLOPT_REFERER, m_Referer);
     
185. }
     
186. 
     
187. void CURL网络传输类2::置TimeOut(INT m_TimeOut)
     
188. {
     
189.     if (m_curl == NULL) {
     
190.         return;
     
191.     }
     
192.     curl_easy_setopt(m_curl, CURLOPT_NOSIGNAL, true); //libcurl支持毫秒, 用户反馈需要开启这个才支持毫秒
     
193.     curl_easy_setopt(m_curl, CURLOPT_CONNECTTIMEOUT_MS, m_TimeOut);
     
194. }
     
195. 
     
196. void CURL网络传输类2::置Nobody()
     
197. {
     
198.     curl_easy_setopt(m_curl, CURLOPT_NOBODY);
     
199. }
     
200. 
     
201. void CURL网络传输类2::置请求头(LPCSTR header)
     
202. {
     
203.     m_RequstHeaderList = curl_slist_append(m_RequstHeaderList, header);
     
204. }
     
205. 
     
206. void CURL网络传输类2::清空请求头()
     
207. {
     
208.     curl_slist_free_all(m_RequstHeaderList);
     
209.     m_RequstHeaderList = NULL;
     
210. }
     
211. 
     
212. void CURL网络传输类2::置请求方式(LPCSTR m_Methed) {
     
213.     if (lstrcmpA(m_Methed, "GET") == 0)
     
214.     {
     
215.         curl_easy_setopt(m_curl, CURLOPT_HTTPGET, 1L);
     
216.     }
     
217.     else if (lstrcmpA(m_Methed, "POST") == 0)
     
218.     {
     
219.         curl_easy_setopt(m_curl, CURLOPT_POST, 1L);
     
220.     }
     
221. }
     
222. 
     
223. VOID CURL网络传输类2::置重定向次数(INT m_MaxRederects)
     
224. {
     
225.     if (m_MaxRederects > 0)
     
226.     {
     
227.         curl_easy_setopt(m_curl, CURLOPT_MAXREDIRS, m_MaxRederects);
     
228.         curl_easy_setopt(m_curl, CURLOPT_FOLLOWLOCATION, 1);
     
229.     }
     
230.     else
     
231.     {
     
232.         curl_easy_setopt(m_curl, CURLOPT_FOLLOWLOCATION, 0);
     
233.     }
     
234. }
     
235. 
     
236. void CURL网络传输类2::启用Cookie记录(LPCSTR m_FilePath)
     
237. {
     
238.     if (m_curl == NULL) {
     
239.         return;
     
240.     }
     
241.     curl_easy_setopt(m_curl, CURLOPT_COOKIEFILE, m_FilePath);
     
242.     curl_easy_setopt(m_curl, CURLOPT_COOKIEJAR, m_FilePath);
     
243. }
     
244. 
     
245. void CURL网络传输类2::置Cookie(LPCSTR m_Cookie)
     
246. {
     
247.     if (m_curl == NULL) {
     
248.         return;
     
249.     }
     
250.     curl_easy_setopt(m_curl, CURLOPT_COOKIE, m_Cookie);
     
251. }
     
252. 
     
253. void CURL网络传输类2::置SSLCert(const char* m_CertFile, const char* m_KeyFile, const char* m_KeyPassword)
     
254. {
     
255.     curl_easy_setopt(m_curl, CURLOPT_SSLCERT, m_CertFile);
     
256.     curl_easy_setopt(m_curl, CURLOPT_SSLKEY, m_KeyFile);
     
257.     curl_easy_setopt(m_curl, CURLOPT_KEYPASSWD, m_KeyPassword);
     
258. }
     
259. 
     
260. void CURL网络传输类2::置SSLCertMem(void* lpCerFileData, int CerFileDataLen, const char* lpszCertType,
     
261.     void* lpKeyFileData, int nKeyFileDataLen, const char* lpszKeyFileType, const char* lpKeyPassword)
     
262. {
     
263.     struct curl_blob stblob;
     
264.     stblob.data = lpCerFileData;
     
265.     stblob.len = CerFileDataLen;
     
266.     stblob.flags = CURL_BLOB_COPY;
     
267.     curl_easy_setopt(m_curl, CURLOPT_SSLCERT_BLOB, &stblob);
     
268.     curl_easy_setopt(m_curl, CURLOPT_SSLCERTTYPE, lpszCertType);
     
269. 
     
270.     struct curl_blob blob;
     
271.     blob.data = lpKeyFileData;
     
272.     blob.len = nKeyFileDataLen;
     
273.     blob.flags = CURL_BLOB_COPY;
     
274.     curl_easy_setopt(m_curl, CURLOPT_SSLKEY_BLOB, &blob);
     
275.     curl_easy_setopt(m_curl, CURLOPT_SSLKEYTYPE, lpszKeyFileType);
     
276. 
     
277.     curl_easy_setopt(m_curl, CURLOPT_KEYPASSWD, lpKeyPassword);
     
278. }
     
279. 
     
280. void CURL网络传输类2::置SSLVerifyPeer(BOOL bVerify)
     
281. {
     
282.     curl_easy_setopt(m_curl, CURLOPT_SSL_VERIFYPEER, bVerify);
     
283. }
     
284. 
     
285. void CURL网络传输类2::置SSLVerifyHost(BOOL bVerify)
     
286. {
     
287.     curl_easy_setopt(m_curl, CURLOPT_SSL_VERIFYHOST, bVerify);
     
288. }
     
289. 
     
290. const char* CURL网络传输类2::取Url()
     
291. {
     
292.     char* url = NULL;
     
293.     curl_easy_getinfo(m_curl, CURLINFO_EFFECTIVE_URL, &url);
     
294.     if (url == NULL) {
     
295.         return "";
     
296.     }
     
297.     return url;
     
298. }
     
299. 
     
300. const char* CURL网络传输类2::取远端IP()
     
301. {
     
302.     char* ip;
     
303.     curl_easy_getinfo(m_curl, CURLINFO_PRIMARY_IP, &ip);
     
304.     if (ip == NULL) {
     
305.         return "";
     
306.     }
     
307.     return ip;
     
308. }
     
309. 
     
310. INT CURL网络传输类2::取远端端口()
     
311. {
     
312.     long port;
     
313.     curl_easy_getinfo(m_curl, CURLINFO_PRIMARY_PORT, &port);
     
314.     return port;
     
315. }
     
316. 
     
317. INT CURL网络传输类2::取状态码()
     
318. {
     
319.     long nResponsCode;
     
320.     curl_easy_getinfo(m_curl, CURLINFO_RESPONSE_CODE, &nResponsCode);
     
321.     return nResponsCode;
     
322. }
     
323. 
     
324. const char* CURL网络传输类2::取错误信息()
     
325. {
     
326.     return m_szErrorBuffer;
     
327. }
     
328. 
     
329. const char* CURL网络传输类2::取响应头()
     
330. {
     
331.     return m_ResponsHead.memory;
     
332. }
     
333. 
     
334. const char* CURL网络传输类2::取响应内容()
     
335. {
     
336.     return m_ResponsBody.memory;
     
337. }
     
338. 
     
339. size_t CURL网络传输类2::取响应内容长度()
     
340. {
     
341.     return m_ResponsBody.size;
     
342. }
     
343. 
     
344. LPCSTR CURL网络传输类2::取跳转地址()
     
345. {
     
346.     if (m_curl == NULL) {
     
347.         return 0;
     
348.     }
     
349.     char* url = NULL;
     
350.     curl_easy_getinfo(m_curl, CURLINFO_EFFECTIVE_URL, &url);
     
351.     return url;
     
352. }
     
353. 
     
354. LPCSTR CURL网络传输类2::取OriginalCookie()
     
355. {
     
356.     if (m_curl == NULL) {
     
357.         return "";
     
358.     }
     
359.     ZeroMemory(m_lpszCookies, sizeof(m_lpszCookies));
     
360.     struct curl_slist* cookies = NULL;
     
361.     CURLcode res = curl_easy_getinfo(m_curl, CURLINFO_COOKIELIST, &cookies);
     
362. 
     
363.     if (!res && cookies) {
     
364.         struct curl_slist* each = cookies;
     
365.         while (each) {
     
366.             lstrcatA(m_lpszCookies, each->data);
     
367.             each = each->next;
     
368.         }
     
369.     }
     
370.     if (cookies) curl_slist_free_all(cookies);
     
371.     return m_lpszCookies;
     
372. }
     
373. 
     
374. LPCSTR CURL网络传输类2::取Cookies()
     
375. {
     
376.     if (m_curl == NULL) {
     
377.         return "";
     
378.     }
     
379.     ZeroMemory(m_lpszCookies, sizeof(m_lpszCookies));
     
380. 
     
381.     struct curl_slist* cookies, * temp;
     
382.     curl_easy_getinfo(m_curl, CURLINFO_COOKIELIST, &cookies);
     
383. 
     
384.     temp = cookies;
     
385.     while (temp) {
     
386.         int nCount = 0;
     
387.         char* pOffset = temp->data;
     
388.         while (*pOffset != 0)
     
389.         {
     
390.             if (*pOffset == '\t') {
     
391.                 nCount++;
     
392.                 if (nCount == 5) break;
     
393.             }
     
394.             pOffset++;
     
395.         }
     
396. 
     
397.         pOffset++;
     
398.         std::string szKey, szValue;
     
399.         while (*pOffset != '\t')
     
400.         {
     
401.             szKey += *pOffset;
     
402.             pOffset++;
     
403.         }
     
404. 
     
405.         pOffset++;
     
406.         szValue = pOffset;
     
407. 
     
408.         lstrcatA(m_lpszCookies, szKey.c_str());
     
409.         lstrcatA(m_lpszCookies, "=");
     
410.         lstrcatA(m_lpszCookies, szValue.c_str());
     
411. 
     
412.         temp = temp->next;
     
413. 
     
414.         if (temp != NULL)
     
415.         {
     
416.             lstrcatA(m_lpszCookies, "; ");
     
417.         }
     
418.     }
     
419. 
     
420.     if (cookies)
     
421.         curl_slist_free_all(cookies);
     
422. 
     
423.     return m_lpszCookies;
     
424. }
     
425. 
     
426. __int64 CURL网络传输类2::取下载时间()
     
427. {
     
428.     if (m_curl == NULL) {
     
429.         return 0;
     
430.     }
     
431.     curl_off_t val = 0;
     
432.     curl_easy_getinfo(m_curl, CURLINFO_TOTAL_TIME_T, &val);
     
433.     return val;
     
434. }
     
435. 
     
436. __int64 CURL网络传输类2::取下载速率()
     
437. {
     
438.     if (m_curl == NULL) {
     
439.         return 0;
     
440.     }
     
441.     curl_off_t val = 0;
     
442.     curl_easy_getinfo(m_curl, CURLINFO_SPEED_DOWNLOAD_T, &val);
     
443.     return val;
     
444. }
     

复制代码

20140706

20140706 发表于 2025-1-3 15:18
对，测过了，多线程跑不了，多线程下 只有最后一个会正常发送请求，按照网上例子，改了下初始化和清理， ...

admin

反馈给群里管理, 让他们处理