自己开发了一个股票软件，功能很强大，需要的点击下面的链接获取：
https://www.cnblogs.com/bclshuai/p/11380657.html
curl_multi 异步高并发服务实现
目录
1 介绍... 1
2 curl_multi异步实现... 1
2.1 curl_multi_poll方式实现异步curl 2
2.1.1 函数调用步骤... 2
2.1.2 实现方案... 2
2.1.3 遇到的问题... 3
2.1.4 curl_multi_poll异步服务封装类实例... 3
2.2 multi_socket实现异步curl 4
1 介绍
https://curl.se/libcurl/c/libcurl-multi.html
libcurl-easy方式是阻塞执行请求，当请求数量过大，或者需要高并发请求时，同步阻塞模式就会显示出性能瓶颈，执行效率低，延时严重，CPU占用率高，程序阻塞卡顿。所以采用异步方式，可以实现高并发请求的应用场景，异步可以在单线程中同时执行多个请求，等待curl文件标志或者自定义文件标志发生变化时，处理请求结果，支持在几千个平行连接上请求数据，基于事件处理结果。
2 curl_multi异步实现
异步请求有两种方式，同步多线程调用会出现CPU占用率过高的情况，导致界面卡死。
有两种方式
（1） 老方式select来判断请求返回结果
（2） multi_socket。
2.1 curl_multi_poll方式实现异步curl
2.1.1 函数调用步骤
（1） curl_multi_init初始化一个multi handle
（2） curl_easy_init 初始化一个easy handle
（3） curl_easy_setopt 给easyhandle设置各种参数
（4） curl_multi_add_handle添加到multihandle
（5） curl_multi_perform异步执行请求，每次执行返回对列中正在运行的数量，为0时，表示执行结束，结束并不意味着所有的请求都成功了，也可能执行失败了。所以需要循环执行该函数。为了减少循环执行的CPU占用率，可以使用curl_multi_poll函数或者curl_multi_fdset配合select函数来判断是否有结果返回，通知读取数据，减少CPU占用。curl_multi_timeout可以为select提供一个合适的超时时间。
（6） curl_multi_info_read 读取返回结果消息队列中的消息，重复调用，直到消息队列为空。返回数据中有个easy handle 用来标识是哪个请求。
（7） curl_multi_remove_handle 将执行结束的easyhandle从multihandle中移除，表示multihandle不再管理此easyhand，可以销毁释放，也可以修改请求连接url和参数，重新加入，复用连接。
（8） curl_easy_cleanup 执行结束后，先清除easy handle
（9） curl_multi_cleanup 执行这个函数，清除multi handle
2.1.2 实现方案
（1） 实现一个服务，程序调用服务的添加任务接口addTask不断的加入任务。
（2） 创建一个线程1不断的从任务队列中取出任务，分配easy handle，给easy_hand设置url等参数。然后添加到multihandle上，去执行请求；并将easyhand和任务之间用map保存起来，表示正在进行的任务；
（3） 创建线程2不断的select或者curl_multi_poll或者curl_multi_wait或者查看multihandle的状态，看是否有数据返回，有数据返回则读取数据。curl_multi_poll和curl_multi_wait比select更好，可以解决连接上限为1024个的问题。curl_multi_poll和curl_multi_wait区别有两个，一个是curl_multi_poll在被等待的时间内，可以调用curl_multi_wakeup激活，curl_multi_poll会加速返回。而curl_multi_wait无法被激活，只能等到有事件触发，或者超时返回。另外一个区别是如果没有文件描述符可以等待，curl_multi_wait会立刻返回，而curl_multi_poll一定要等到超时时间才能返回。
（4） 读取数据会返回easyhand，用easyhand去map中查找对应的任务；然后根据不同的任务属性去处理数据，调用回调函数，将数据返回给程序。
2.1.3 遇到的问题
（1） 出现崩溃，可能是多线程调用libcurl接口的原因；
（2） curl_multi_add_handle添加easyhand返回失败，errocode：8，CURLM_RECURSIVE_API_CALL，错误原因是从回调内部调用API函数。没有找到解决办法，可能和多线程调用有关。设置超时时间curl_easy_setopt(curl, CURLOPT_TIMEOUT, 30); 超时设置为0时会出现崩溃，设置成0表示不超时；并且设置不发出信号，curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);解决问题。
（3） 当使用的easyhand太多时，200个，会出现错误码CURLE_COULDNT_CONNECT ，7的错误，意识无法连接（）到主机或代理。connect refused。连接数量太多，需要创建太多socket连接，而服务器端创建的连接数量有限，导致失败。
（4） 一次向multihand添加1000条任务，curl_multi_perform执行返回任务从1000降到0后，并不是所有分任务都执行完了，读取的数据也就600条左右，需要多次调用curl_multi_info_read去读取数据。
2.1.4 curl_multi_poll异步服务封装类实例
本代码实例采用curl_multi_poll实现异步消息的等待，比select性能更加，去除了select上限1024的束缚。把异步请求调用过程封装成一个服务形式，所有的异步请求都可以发给服务去执行，然后通过回调函数返回结果。其中easyhand做成一个连接池的形式，可以重复使用，并且可以复用连接，提高了请求性能。代码实例中运用到了C++11新特性的内容，包括智能指针、std::thread、std::move等。
（1） 封装类头文件
#pragma once #include"curl.h" #include <mutex> #include <condition_variable> #include"BaseDefine.h" class CurlSelectMulti { public: CurlSelectMulti(); ~CurlSelectMulti(); //全局初始化 static void GlobalInit(); //全局反初始化 void GlobleFint(); //初始化 int init(); //反初始化 void finit(); //添加任务到队列 void addTask(shared_ptr<Task>& task); private: //处理任务，循环从对列中获取数据，添加到muitihand void dealTask(); //检查是否有任务完成 void handTaskResult(); //读取已完成的任务进行解析 void readTaskResult(); //从easyhand队列中获取easyhand，没有则新建一个 CURL* GetCurl(); //新建一个easyhand CURL* CreateCurl(); //将使用完的easyhand放入队列 void PutCurl(CURL* curl); //将任务添加到mulitihand，执行任务 void addTaskToMultiRequest(list<shared_ptr<Task>>& listTask); //给easyhand设置参数 int setTaskParameter(CURL* easyhand, shared_ptr<Task>& task); bool m_bDebug=false; CURL* m_pMultiHand=nullptr;//多操作句柄 list<shared_ptr<Task>> m_listTask;//任务列表 mutex m_taskMutex;//任务列表的锁 mutex m_easyHandMutex;//easyhand队列的锁 list<CURL*>m_listEasyHand;// easyhand队列 bool m_bRunning = true;//线程控制函数 thread m_taskAddThread;//投递任务的的线程 thread m_taskHandThread;//判断任务状态， 处理任务的线程 condition_variable m_conVarTask; map<CURL*, std::shared_ptr<Task>> m_mapRuningTask;//正在执行的任务 mutex m_runningTaskMutex; mutex m_curlApiMutex;//多线程调用curl的接口时会出现崩溃，这里加个锁 int m_curlnum = 0;// int m_successnum=0; int m_failednum = 0; int m_addmultFailed; };
（2） 封装类源文件
#include "stdafx.h" #include "CurlSelectMulti.h" static int OnDebug(CURL *, curl_infotype itype, char * pData, size_t size, void *) { if (itype == CURLINFO_TEXT) { //printf("[TEXT]%s\n", pData); } else if (itype == CURLINFO_HEADER_IN) { printf("[HEADER_IN]%s\n", pData); } else if (itype == CURLINFO_HEADER_OUT) { printf("[HEADER_OUT]%s\n", pData); } else if (itype == CURLINFO_DATA_IN) { printf("[DATA_IN]%s\n", pData); } else if (itype == CURLINFO_DATA_OUT) { printf("[DATA_OUT]%s\n", pData); } return 0; } static size_t OnWriteData(void* buffer, size_t size, size_t nmemb, void* lpVoid) { std::string* str = dynamic_cast<std::string*>((std::string *)lpVoid); if (NULL == str || NULL == buffer) { return -1; } char* pData = (char*)buffer; str->append(pData, size * nmemb); return nmemb; } CurlSelectMulti::CurlSelectMulti() { } CurlSelectMulti::~CurlSelectMulti() { finit(); } void CurlSelectMulti::GlobalInit() { curl_global_init(CURL_GLOBAL_ALL); } void CurlSelectMulti::GlobleFint() { curl_global_cleanup(); } int CurlSelectMulti::init() { //创建一个multi句柄 m_pMultiHand = curl_multi_init(); if (m_pMultiHand == nullptr) { return false; } m_bRunning = true; m_taskAddThread=std::move(thread(std::bind(&CurlSelectMulti::dealTask, this))); m_taskHandThread = std::move(thread(std::bind(&CurlSelectMulti::handTaskResult,this))); //m_taskAddThread.join(); //m_taskHandThread.join(); return true; } void CurlSelectMulti::finit() { //让线程自动退出 m_bRunning = false; //通知不在等待 m_conVarTask.notify_all(); //清除所有的easycurl while (m_listEasyHand.size()>0) { auto it = move(m_listEasyHand.front()); curl_multi_remove_handle(m_pMultiHand,it); curl_easy_cleanup(it); m_listEasyHand.pop_front(); } //清除multihand if (m_pMultiHand != nullptr) { curl_multi_cleanup(m_pMultiHand); m_pMultiHand = nullptr; } } void CurlSelectMulti::addTask(shared_ptr<Task>& task) { if (m_listTask.size() > 5000) { //printf("task is full size %d ,abord task %d", m_listTask.size(),task->taskid); return; } unique_lock<mutex> lk(m_taskMutex); m_listTask.push_back(task); //m_conVarTask.notify_one();//通知有任务添加 lk.unlock(); } CURL* CurlSelectMulti::GetCurl() { CURL* curl = NULL; m_easyHandMutex.lock(); if (m_listEasyHand.size()>0) { curl = m_listEasyHand.front(); m_listEasyHand.pop_front(); } m_easyHandMutex.unlock(); if (curl == NULL) { curl = CreateCurl(); } return curl; } CURL* CurlSelectMulti::CreateCurl() { if (m_curlnum >100)//数量太多会出现连接失败的error { return NULL; } m_curlnum++; printf("curl num %d", m_curlnum); CURL* curl = curl_easy_init(); if (NULL == curl) { return NULL; } if (m_bDebug) { curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION, OnDebug); } //curl_easy_setopt(curl, CURLOPT_URL, strUrl.c_str()); curl_easy_setopt(curl, CURLOPT_READFUNCTION, NULL); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, OnWriteData); //curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&strResponse); /* enable TCP keep-alive for this transfer */ curl_easy_setopt(curl, CURLOPT_TCP_KEEPALIVE, 1L); /* keep-alive idle time to 120 seconds */ curl_easy_setopt(curl, CURLOPT_TCP_KEEPIDLE, 300L); /* interval time between keep-alive probes: 60 seconds */ curl_easy_setopt(curl, CURLOPT_TCP_KEEPINTVL, 200L); curl_easy_setopt(curl, CURLOPT_TIMEOUT, 100); //支持重定向 curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1); //保持会话，不用反复创建连接，据说可以提高效率 curl_easy_setopt(curl, CURLOPT_COOKIESESSION, 1); //设置共享dns cache功能，据说能提高性能 curl_share_setopt(curl, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS); //不验证主机名称 curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0); curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0); //不验证对端的证书 //curl_easy_setopt(curl, CURLOPT_CAINFO, c->msg._caPath.c_str()); /** * 当多个线程都使用超时处理的时候，同时主线程中有sleep或是wait等操作。 * 如果不设置这个选项，libcurl将会发信号打断这个wait从而导致程序退出。 */ curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L); curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 100); return curl; } void CurlSelectMulti::PutCurl(CURL* curl) { m_easyHandMutex.lock(); m_listEasyHand.push_back(curl); m_easyHandMutex.unlock(); //m_conVarEasyHand.notify_all(); } void CurlSelectMulti::dealTask() { while (m_bRunning) { unique_lock<mutex> lk(m_taskMutex); //m_conVarTask.wait(lk);//等待任务添加 if (m_listTask.size() > 0) { list<shared_ptr<Task>> listTask; listTask.swap(m_listTask); lk.unlock(); addTaskToMultiRequest(listTask); } else { lk.unlock(); Sleep(20); } } } void CurlSelectMulti::handTaskResult() { CURLMcode mc = CURLM_OK; int still_running = 0; int ret = 0; while (m_bRunning) { m_curlApiMutex.lock(); //执行请求，并返回正在执行的请求数量 mc = curl_multi_perform(m_pMultiHand, &still_running); //printf("still running num%d,%d\n", still_running, mc); m_curlApiMutex.unlock(); //等待有任务完成的通知，有结果时立刻返回，没有结果时1000ms后等待结束返回,ret返回完成的任务数量 mc = curl_multi_poll(m_pMultiHand, NULL, 0, 1000, &ret); if (mc == CURLM_OK)//有任务 { readTaskResult(); } else { printf("curl_multi_poll error %d", mc); } //if (still_running>0)//有正在执行的请求任务 //{ // while (still_running>0) // { // // //再次执行curl_multi_perform，更新still_running // mc = curl_multi_perform(m_pMultiHand, &still_running); // //printf("still running num%d\n", still_running); // } // printf("task finish\n"); //} //else//没有任务，则等一会，避免一直循环，cpu占用过高 //{ // Sleep(100); //} } } void CurlSelectMulti::readTaskResult() { CURLMsg* m = NULL; do { int msgq = 0; m_curlApiMutex.lock(); m = curl_multi_info_read(m_pMultiHand, &msgq); m_curlApiMutex.unlock(); if (m && (m->msg == CURLMSG_DONE)) { CURL *e = m->easy_handle; // 数据处理 auto it = m_mapRuningTask.find(e); if (it != m_mapRuningTask.end()) { if (m->data.result != 0) { m_failednum++; printf("request error %d,failednum%d,taskid%d,%s\n", m->data.result, m_failednum, m_mapRuningTask[e]->taskid, m_mapRuningTask[e]->strUrl.c_str()); } else { m_successnum++; printf("request success successnum%d,id %d, \n ", m_successnum, m_mapRuningTask[e]->taskid);//, , m_mapRuningTask[e]->strResponse.c_str() } //移除easyhand m_curlApiMutex.lock(); curl_multi_remove_handle(m_pMultiHand, e); m_curlApiMutex.unlock(); //从map中移除 m_runningTaskMutex.lock(); if (it->second->headers != nullptr)//清除数据 { curl_slist_free_all(it->second->headers); } m_mapRuningTask.erase(it); m_runningTaskMutex.unlock(); //放回对列中重复使用 PutCurl(e); } else { //移除easyhand m_curlApiMutex.lock(); curl_multi_remove_handle(m_pMultiHand, e); m_curlApiMutex.unlock(); printf( "find map key failed" ); PutCurl(e); } } } while (m); } void CurlSelectMulti::addTaskToMultiRequest(list<shared_ptr<Task>>& listTask) { while (listTask.empty()==false) { auto item = listTask.front(); CURL* easyhand = GetCurl();//获取easyhand if (easyhand == NULL) { //unique_lock<mutex> lk(m_easyHandMutex); //m_conVarEasyHand.wait(lk);//等待有easyhand被放入 Sleep(1); continue; } //根据任务设置参数，设置url，timeout等参数到easyhand //使用智能指针，指向在堆上创建的对象 /*shared_ptr<Task> task(new Task()); *task = item;*/ if (setTaskParameter(easyhand, item) != 0) { Sleep(2); PutCurl(easyhand); continue; } //将设置好参数的easyhand添加到multihand m_curlApiMutex.lock(); CURLMcode code = curl_multi_add_handle(m_pMultiHand, easyhand);//当任务数量太大时出现添加失败错误码8，有时还崩溃。 m_curlApiMutex.unlock(); if (code!= CURLM_OK) { m_addmultFailed++; string strerror= curl_multi_strerror(code); printf("curl_multi_add_handle failed%d,%s\n", m_addmultFailed, strerror.c_str()); PutCurl(easyhand);// continue; } //加入成功后将easyhand和task加入map，便于返回结果时通过easyhand去查找任务 m_runningTaskMutex.lock(); m_mapRuningTask.insert({ easyhand, item }); printf("running task size:%d\n", m_mapRuningTask.size()); m_runningTaskMutex.unlock(); listTask.pop_front(); } } int CurlSelectMulti::setTaskParameter(CURL* easyhand, shared_ptr<Task>& task) { CURLcode code = CURLE_OK; do { if (task->iType == HttpType::HTTP_POST || task->iType == HttpType::HTTPS_POST) { code = curl_easy_setopt(easyhand, CURLOPT_POST, 1); //post方法 if (code!= CURLE_OK) { printf("curl_easy_setopt error %d", code); break; } code = curl_easy_setopt(easyhand, CURLOPT_POSTFIELDSIZE, task->strPostContent.size()); if (code != CURLE_OK) { printf("curl_easy_setopt error %d", code); break; } code = curl_easy_setopt(easyhand, CURLOPT_POSTFIELDS, task->strPostContent.data()); if (code != CURLE_OK) { printf("curl_easy_setopt error %d", code); break; } } //设置url code = curl_easy_setopt(easyhand, CURLOPT_URL, task->strUrl.c_str()); if (code != CURLE_OK) { printf("curl_easy_setopt error %d", code); break; } code = curl_easy_setopt(easyhand, CURLOPT_WRITEDATA, (void *)&(task->strResponse)); if (code != CURLE_OK) { printf("curl_easy_setopt error %d", code); break; } //设置协议头 if (task->headers != nullptr) { code=curl_easy_setopt(easyhand, CURLOPT_HTTPHEADER, task->headers); if (code != CURLE_OK) { printf("curl_easy_setopt error %d", code); break; } } } while (0); if (code!=CURLE_OK)//清除掉无效的easyhand { printf("setTaskParameter error"); PutCurl(easyhand); return -1; } return 0; }
（3） 服务封装类使用实例
// CurlMultiServer.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <iostream> #include <fstream> #include <thread> #include "CurlSelectMulti.h" #include "CurlSocketMulti.h" using namespace std; int main() { CurlSelectMulti m_multServer; m_multServer.GlobalInit(); m_multServer.init(); int taskid=0; int time = 0; //while (true) { for (int i = 0; i < 10000; i++) { shared_ptr<Task> task = std::make_shared<Task>(); task->iType = HttpType::HTTPS_GET; task->strUrl = ""; taskid++; task->taskid = taskid; m_multServer.addTask(task); } //Sleep(1000); //printf("using time %ds,task num %d",(time++) * 1, time * 100); } getchar(); return 0; }
（4） 性能测试
在如下电脑配置条件下，请求了某个http请求1万次，所用时间14秒，平均一次1.4毫秒。每秒714次请求调用。
另外还有multi_socket和事件libevent结合的方式，且听下回分解。