libcurl进行异步并发

        libcurl的easy 接口，easy接口的使用非常的简单，curl_easy_init用来初始化一个easy curl对象，curl_easy_setopt对easy curl对象进行相关设置，最后curl_easy_perform执行curl请求，返回相应结果。easy接口是阻塞的，也就是说必须等到上一个curl请求执行完后，下一个curl请求才能继续执行，在一般的应用场合，这种阻塞的访问方式是没有问题的，但是当程序需要进行多次curl并发请求的时候，easy接口就无能为力了，这个时候curl提供的multi接口就派上用场了.

相比而言，multi接口的使用会比easy 接口稍微复杂点，毕竟multi接口是依赖easy接口的，首先粗略的讲下其使用流程：curl_multi _init初始化一个multi curl对象，为了同时进行多个curl的并发访问，我们需要初始化多个easy curl对象，使用curl_easy_setopt进行相关设置，然后调用curl_multi _add_handle把easy curl对象添加到multi curl对象中，添加完毕后执行curl_multi_perform方法进行并发的访问，访问结束后curl_multi_remove_handle移除相关easy curl对象，curl_easy_cleanup清除easy curl对象，最后curl_multi_cleanup清除multi curl对象。

上面的介绍只是给大家一个大概的印象，实际使用中还有很多细节需要注意，好了，代码才能说明一切，下面的例子使用multi curl方式进行多次http并发访问，并输出访问结果。

1. #include <string>
2. #include <iostream>
4. #include <curl/curl.h>
5. #include <sys/time.h>
6. #include <unistd.h>
8. using namespace std;
10. size_t curl_writer(void *buffer, size_t size, size_t count, void * stream)
11. {
12.     std::string * pStream = static_cast<std::string *>(stream);
13.     (*pStream).append((char *)buffer, size * count);
15.     return size * count;
16. };
18. /**
19.  * 生成一个easy curl对象，进行一些简单的设置操作
20.  */
21. CURL * curl_easy_handler(const std::string & sUrl,
22.                          const std::string & sProxy,
23.                          std::string & sRsp,
24.                          unsigned int uiTimeout)
25. {
26.     CURL * curl = curl_easy_init();
28.     curl_easy_setopt(curl, CURLOPT_URL, sUrl.c_str());
29.     curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
31.     if (uiTimeout > 0)
32.     {
33.         curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, uiTimeout);
34.     }
35.     if (!sProxy.empty())
36.     {
37.         curl_easy_setopt(curl, CURLOPT_PROXY, sProxy.c_str());
38.     }
40.     // write function //
41.     curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_writer);
42.     curl_easy_setopt(curl, CURLOPT_WRITEDATA, &sRsp);
44.     return curl;
45. }
47. /**
48.  * 使用select函数监听multi curl文件描述符的状态
49.  * 监听成功返回0，监听失败返回-1
50.  */
51. int curl_multi_select(CURLM * curl_m)
52. {
53.     int ret = 0;
55.     struct timeval timeout_tv;
56.     fd_set  fd_read;
57.     fd_set  fd_write;
58.     fd_set  fd_except;
59.     int     max_fd = -1;
61.     // 注意这里一定要清空fdset,curl_multi_fdset不会执行fdset的清空操作  //
62.     FD_ZERO(&fd_read);
63.     FD_ZERO(&fd_write);
64.     FD_ZERO(&fd_except);
66.     // 设置select超时时间  //
67.     timeout_tv.tv_sec = 1;
68.     timeout_tv.tv_usec = 0;
70.     // 获取multi curl需要监听的文件描述符集合 fd_set //
71.     curl_multi_fdset(curl_m, &fd_read, &fd_write, &fd_except, &max_fd);
73.     /**
74.      * When max_fd returns with -1,
75.      * you need to wait a while and then proceed and call curl_multi_perform anyway.
76.      * How long to wait? I would suggest 100 milliseconds at least,
77.      * but you may want to test it out in your own particular conditions to find a suitable value.
78.      */
79.     if (-1 == max_fd)
80.     {
81.         return -1;
82.     }
84.     /**
85.      * 执行监听，当文件描述符状态发生改变的时候返回
86.      * 返回0，程序调用curl_multi_perform通知curl执行相应操作
87.      * 返回-1，表示select错误
88.      * 注意：即使select超时也需要返回0，具体可以去官网看文档说明
89.      */
90.     int ret_code = ::select(max_fd + 1, &fd_read, &fd_write, &fd_except, &timeout_tv);
91.     switch(ret_code)
92.     {
93.     case -1:
94.         /* select error */
95.         ret = -1;
96.         break;
97.     case 0:
98.         /* select timeout */
99.     default:
100.         /* one or more of curl’s file descriptors say there’s data to read or write*/
101.         ret = 0;
102.         break;
103.     }
105.     return ret;
106. }
108. #define MULTI_CURL_NUM 3
110. // 这里设置你需要访问的url //
111. std::string     URL     = “http://website.com”;
112. // 这里设置代理ip和端口  //
113. std::string     PROXY   = “ip:port”;
114. // 这里设置超时时间  //
115. unsigned int    TIMEOUT = 2000; /* ms */
117. /**
118.  * multi curl使用demo
119.  */
120. int curl_multi_demo(int num)
121. {
122.     // 初始化一个multi curl 对象 //
123.     CURLM * curl_m = curl_multi_init();
125.     std::string     RspArray[num];
126.     CURL *          CurlArray[num];
128.     // 设置easy curl对象并添加到multi curl对象中  //
129.     for (int idx = 0; idx < num; ++idx)
130.     {
131.         CurlArray[idx] = NULL;
132.         CurlArray[idx] = curl_easy_handler(URL, PROXY, RspArray[idx], TIMEOUT);
133.         if (CurlArray[idx] == NULL)
134.         {
135.             return -1;
136.         }
137.         curl_multi_add_handle(curl_m, CurlArray[idx]);
138.     }
140.     /*
141.      * 调用curl_multi_perform函数执行curl请求
142.      * url_multi_perform返回CURLM_CALL_MULTI_PERFORM时，表示需要继续调用该函数直到返回值不是CURLM_CALL_MULTI_PERFORM为止
143.      * running_handles变量返回正在处理的easy curl数量，running_handles为0表示当前没有正在执行的curl请求
144.      */
145.     int running_handles;
146.     while (CURLM_CALL_MULTI_PERFORM == curl_multi_perform(curl_m, &running_handles))////执行并发请求，非阻塞，立即返回
147.     {
148.         cout << running_handles << endl;
149.     }
151.     /**
152.      * 为了避免循环调用curl_multi_perform产生的cpu持续占用的问题，采用select来监听文件描述符
153.      */
154.     while (running_handles)
155.     {
156.         if (-1 == curl_multi_select(curl_m))
157.         {
158.             cerr << “select error” << endl;
159.             break;
160.         } else {
161.             // select监听到事件，调用curl_multi_perform通知curl执行相应的操作 //
162.             while (CURLM_CALL_MULTI_PERFORM == curl_multi_perform(curl_m, &running_handles))
163.             {
164.                 cout << “select: “ << running_handles << endl;
165.             }
166.         }
167.         cout << “select: “ << running_handles << endl;
168.     }
170.     // 输出执行结果 //
171.     int         msgs_left;
172.     CURLMsg *   msg;
173.     while((msg = curl_multi_info_read(curl_m, &msgs_left)))
174.     {
175.         if (CURLMSG_DONE == msg->msg)
176.         {
177.             int idx;
178.             for (idx = 0; idx < num; ++idx)
179.             {
180.                 if (msg->easy_handle == CurlArray[idx]) break;
181.             }
183.             if (idx == num)
184.             {
185.                 cerr << “curl not found” << endl;
186.             } else
187.             {
188.                 cout << “curl [“ << idx << “] completed with status: “
189.                         << msg->data.result << endl;
190.                 cout << “rsp: “ << RspArray[idx] << endl;
191.             }
192.         }
193.     }
195.     // 这里要注意cleanup的顺序 //
196.     for (int idx = 0; idx < num; ++idx)
197.     {
198.         curl_multi_remove_handle(curl_m, CurlArray[idx]);
199.     }
201.     for (int idx = 0; idx < num; ++idx)
202.     {
203.         curl_easy_cleanup(CurlArray[idx]);
204.     }
206.     curl_multi_cleanup(curl_m);
208.     return 0;
209. }
211. /**
212.  * easy curl使用demo
213.  */
214. int curl_easy_demo(int num)
215. {
216.     std::string     RspArray[num];
218.     for (int idx = 0; idx < num; ++idx)
219.     {
220.         CURL * curl = curl_easy_handler(URL, PROXY, RspArray[idx], TIMEOUT);
221.         CURLcode code = curl_easy_perform(curl);
222.         cout << “curl [“ << idx << “] completed with status: “
223.                 << code << endl;
224.         cout << “rsp: “ << RspArray[idx] << endl;
226.         // clear handle //
227.         curl_easy_cleanup(curl);
228.     }
230.     return 0;
231. }
233. #define USE_MULTI_CURL
235. struct timeval begin_tv, end_tv;
237. int main(int argc, char * argv[])
238. {
239.     if (argc < 2)
240.     {
241.         return -1;
242.     }
243.     int num = atoi(argv[1]);
245.     // 获取开始时间 //
246.     gettimeofday(&begin_tv, NULL);
247. #ifdef USE_MULTI_CURL
248.     // 使用multi接口进行访问 //
249.     curl_multi_demo(num);
250. #else
251.     // 使用easy接口进行访问 //
252.     curl_easy_demo(num);
253. #endif
254.     // 获取结束时间  //
255.     struct timeval end_tv;
256.     gettimeofday(&end_tv, NULL);
258.     // 计算执行延时并输出，用于比较  //
259.     int eclapsed = (end_tv.tv_sec – begin_tv.tv_sec) * 1000 +
260.                    (end_tv.tv_usec – begin_tv.tv_usec) / 1000;
262.     cout << “eclapsed time:” << eclapsed << “ms” << endl;
264.     return 0;
265. }

curl官网上提供的文件上传例子:

1. /* This is an example application source code using the multi interface
2.  * to do a multipart formpost without “blocking”. */
3. #include <stdio.h>
4. #include <string.h>
5. #include <sys/time.h>
7. #include <curl/curl.h>
9. int main(void)
10. {
11.   CURL *curl;
13.   CURLM *multi_handle;
14.   int still_running;
16.   struct curl_httppost *formpost=NULL;
17.   struct curl_httppost *lastptr=NULL;
18.   struct curl_slist *headerlist=NULL;
19.   static const char buf[] = “Expect:”;
21.   /* Fill in the file upload field. This makes libcurl load data from
22.      the given file name when curl_easy_perform() is called. */
23.   curl_formadd(&formpost,
24.                &lastptr,
25.                CURLFORM_COPYNAME, “sendfile”,
26.                CURLFORM_FILE, “postit2.c”,
27.                CURLFORM_END);
29.   /* Fill in the filename field */
30.   curl_formadd(&formpost,
31.                &lastptr,
32.                CURLFORM_COPYNAME, “filename”,
33.                CURLFORM_COPYCONTENTS, “postit2.c”,
34.                CURLFORM_END);
36.   /* Fill in the submit field too, even if this is rarely needed */
37.   curl_formadd(&formpost,
38.                &lastptr,
39.                CURLFORM_COPYNAME, “submit”,
40.                CURLFORM_COPYCONTENTS, “send”,
41.                CURLFORM_END);
43.   curl = curl_easy_init();
44.   multi_handle = curl_multi_init();
46.   /* initalize custom header list (stating that Expect: 100-continue is not
47.      wanted */
48.   headerlist = curl_slist_append(headerlist, buf);
49.   if(curl && multi_handle) {
51.     /* what URL that receives this POST */
52.     curl_easy_setopt(curl, CURLOPT_URL, “http://www.example.com/upload.cgi”);
53.     curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
55.     curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headerlist);
56.     curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
58.     curl_multi_add_handle(multi_handle, curl);
60.     curl_multi_perform(multi_handle, &still_running);
62.     do {
63.       struct timeval timeout;
64.       int rc; /* select() return code */
66.       fd_set fdread;
67.       fd_set fdwrite;
68.       fd_set fdexcep;
69.       int maxfd = -1;
71.       long curl_timeo = -1;
73.       FD_ZERO(&fdread);
74.       FD_ZERO(&fdwrite);
75.       FD_ZERO(&fdexcep);
77.       /* set a suitable timeout to play around with */
78.       timeout.tv_sec = 1;
79.       timeout.tv_usec = 0;
81.       curl_multi_timeout(multi_handle, &curl_timeo);
82.       if(curl_timeo >= 0) {
83.         timeout.tv_sec = curl_timeo / 1000;
84.         if(timeout.tv_sec > 1)
85.           timeout.tv_sec = 1;
86.         else
87.           timeout.tv_usec = (curl_timeo % 1000) * 1000;
88.       }
90.       /* get file descriptors from the transfers */
91.       curl_multi_fdset(multi_handle, &fdread, &fdwrite, &fdexcep, &maxfd);
93.       /* In a real-world program you OF COURSE check the return code of the
94.          function calls.  On success, the value of maxfd is guaranteed to be
95.          greater or equal than -1.  We call select(maxfd + 1, …), specially in
96.          case of (maxfd == -1), we call select(0, …), which is basically equal
97.          to sleep. */
99.       rc = select(maxfd+1, &fdread, &fdwrite, &fdexcep, &timeout);
101.       switch(rc) {
102.       case -1:
103.         /* select error */
104.         break;
105.       case 0:
106.       default:
107.         /* timeout or readable/writable sockets */
108.         printf(“perform!\n”);
109.         curl_multi_perform(multi_handle, &still_running);
110.         printf(“running: %d!\n”, still_running);
111.         break;
112.       }
113.     } while(still_running);
115.     curl_multi_cleanup(multi_handle);
117.     /* always cleanup */
118.     curl_easy_cleanup(curl);
120.     /* then cleanup the formpost chain */
121.     curl_formfree(formpost);
123.     /* free slist */
124.     curl_slist_free_all (headerlist);
125.   }
126.   return 0;
127. }