高并发HTTP请求实践

2021-04-13 15:54:51 浏览数 (1)

当今，正处于互联网高速发展的时代，每个人的生活都离不开互联网，互联网已经影响了每个人生活的方方面面。我们使用淘宝、京东进行购物，使用微信进行沟通，使用美图秀秀进行拍照美化等等。而这些每一步的操作下面，都离不开一个技术概念HTTP(Hypertext Transfer Protocol，超文本传输协议)。

举个?，当我们打开京东APP的时候，首先进入的是开屏页面，然后进入首页。在开屏一般是广告，而首页是内容相关，包括秒杀，商品推荐以及各个tag页面，而各个tag也有其对应的内容。当我们在进入开屏之前或者开屏之后(这块依赖于各个app的技术实现)，会向后端服务发送一个http请求，这个请求会带上该页面广告位信息，向后端要内容，后端根据广告位的配置，挑选一个合适的广告或者推荐商品返回给APP端进行展示。在这里，为了描述方便，后端当做一个简单的整体，实际上，后端会有非常复杂的业务调度，比如获取用户画像，广告定向，获取素材，计算坐标，返回APP，APP端根据坐标信息，下载素材，然后进行渲染，从而在用户端进行展示，这一切都是秒级甚至毫秒级响应，一个高效的HTTP Client在这里就显得尤为重要，本文主要从业务场景来分析，如何实现一个高效的HTTP Client。

1

概念

当我们需要模拟发送一个http请求的时候，往往有两种方式：

1、通过浏览器

2、通过curl命令进行发送请求

如果我们在大规模高并发的业务中，如果使用curl来进行http请求，其效果以及性能是不能满足业务需求的，这就引入了另外一个概念libcurl。

curl

利用URL语法在命令行方式下工作的开源文件传输工具。 它支持很多协议：DICT, FILE, FTP, FTPS, Gopher, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, POP3, POP3S, RTMP, RTSP, SCP, SFTP, SMTP, SMTPS, Telnet and TFTP。

支持SSL证书,HTTP POST, HTTP PUT,FTP上传，基于表单的HTTP上传，代理(proxies)、cookies、用户名/密码认证(Basic, Digest, NTLM等)、下载文件断点续传，上载文件断点续传(file transfer resume)，http代理服务器管道（proxy tunneling)以及其他特性。

libcurl

一个免费开源的，客户端url传输库，支持DICT, FILE, FTP, FTPS, Gopher, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, POP3, POP3S, RTMP, RTSP, SCP, SFTP, SMTP, SMTPS, Telnet and TFTP等协议。

支持SSL证书,HTTP POST, HTTP PUT,FTP上传，基于表单的HTTP上传，代理(proxies)、cookies、用户名/密码认证(Basic, Digest, NTLM等)、下载文件断点续传，上载文件断点续传(file transfer resume)，http代理服务器管道（proxy tunneling)等。

高度可移植，可以工作在不同的平台上，支持Windows，Unix，Linux等。

免费的，线程安全的，IPV6兼容的，同事它还有很多其他非常丰富的特性。libcurl已经被很多知名的大企业以及应用程序所采用。

特点

curl和libcurl都可以利用多种多样的协议来传输文件，包括HTTP, HTTPS, FTP, FTPS, GOPHER, LDAP, DICT, TELNET and FILE等

支持SSL证书,HTTP POST, HTTP PUT,FTP上传，基于表单的HTTP上传，代理(proxies)、cookies、用户名/密码认证(Basic, Digest, NTLM等)、下载文件断点续传，上载文件断点续传(file transfer resume)，http代理服务器管道（proxy tunneling)等。

libcurl是一个库，通常与别的程序绑定在一起使用，如命令行工具curl就是封装了libcurl库。所以我们也可以在你自己的程序或项目中使用libcurl以获得类似CURL的强大功能。

2

实现

在开始实现client发送http请求之前，我们先理解两个概念：

同步请求

当客户端向服务器发送同步请求时，服务处理在请求的过程中，客户端会处于等待的状态，一直等待服务器处理完成，客户端将服务端处理后的结果返回给调用方。

异步请求

客户端把请求发送给服务器之后，不会等待服务器返回，而是去做其他事情，待服务器处理完成之后，通知客户端该事件已经完成，客户端在获取到通知后，将服务器处理后的结果返回给调用方。

通过这俩概念，就能看出，异步在实现上，要比同步复杂的多。同步，即我们简单的等待处理结果，待处理结果完成之后，再返回调用方。而对于异步，往往在实现上，需要各种回调机制，各种通知机制，即在处理完成的时候，需要知道是哪个任务完成了，从而通知客户端去处理该任务完成后剩下的逻辑。

下面，我们将从代码实现的角度，来更深一步的理解libcurl在实现同步和异步请求操作上的区别，从而更近异步的了解同步和异步的实现原理

。

同步

使用libcurl完成同步http请求，原理和代码都比较简单，主要是分位以下几个步骤：

1、初始化easy handle

2、在该easy handle上设置相关参数，在本例中主要有以下几个参数

  • CURLOPT_URL，即请求的url
  • CURLOPT_WRITEFUNCTION，即回调函数，将http server返回数据写入对应的地方
  • CURLOPT_FOLLOWLOCATION，是否获取302跳转后的内容
  • CURLOPT_POSTFIELDSIZE，此次发送的数据大小
  • CURLOPT_POSTFIELDS，此次发送的数据内容
  • 更多的参数设置，请参考libcurl官网

3、curl_easy_perform，调用该函数发送http请求，并同步等待返回结果

4、curl_easy_cleanup，释放步骤一中申请的easy handle资源

代码实现(easy_curl.cc)

代码语言：javascript复制
#include <curl/curl.h>
#include <iostream>
#include <string>

std::string resp;
size_t WriteData(
        char* buffer, size_t size,
        size_t nmemb, void* userp) {
  resp.append(buffer, size * nmemb);
  return size * nmemb;
}

int main(void) {
  CURLcode res;
  CURL *curl = curl_easy_init(); 
  std::string post = "abc";
  
  if(curl) {
    // 设置url
    curl_easy_setopt(curl, CURLOPT_URL, "https://www.baidu.com");
    
    // 设置回调函数，即当有返回的时候，调用回调函数WriteData
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteData);
    
    // 抓取302跳转后d额内容
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION,1); 

    // 设置发送的内容大小  
    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, post.size());

    // 设置发送的内容
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, post.c_str());    
   
    // 开始执行http请求，此处是同步的，即等待http服务器响应
    res = curl_easy_perform(curl);
    /* Check for errors */ 
    if(res != CURLE_OK)
      fprintf(stderr, "curl_easy_perform() failed: %sn",
              curl_easy_strerror(res));
    /* always cleanup */ 
    curl_easy_cleanup(curl);
  }
  
  std::cout << resp << std::endl;
  return 0;
}

编译

代码语言：javascript复制
g   --std=c  11 easy_curl.cc -I ../artifacts/include/ -L ../artifacts/lib -lcurl -o easy_curl

结果

代码语言：javascript复制
<!DOCTYPE html>
<!--STATUS OK-->
<html>
<head>
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <meta http-equiv="content-type" content="text/html;charset=utf-8">
    <meta content="always" name="referrer">
    <script src="https://ss1.bdstatic.com/5eN1bjq8AAUYm2zgoY3K/r/www/nocache/imgdata/seErrorRec.js"></script>
    <title>页面不存在_百度搜索</title>
    <style data-for="result">
        body {color: #333; background: #fff; padding: 0; margin: 0; position: relative; min-width: 700px; font-family: arial; font-size: 12px }
        p, form, ol, ul, li, dl, dt, dd, h3 {margin: 0; padding: 0; list-style: none }
        input {padding-top: 0; padding-bottom: 0; -moz-box-sizing: border-box; -webkit-box-sizing: border-box; box-sizing: border-box } img {border: none; }
        .logo {width: 117px; height: 38px; cursor: pointer }
         #wrapper {_zoom: 1 }
        #head {padding-left: 35px; margin-bottom: 20px; width: 900px }
        ...

异步

接触过网络编程的读者，都或多或少的了解多路复用的原理。IO多路复用在Linux下包括了三种，select、poll、epoll，抽象来看，他们功能是类似的，但具体细节各有不同：首先都会对一组文件描述符进行相关事件的注册，然后阻塞等待某些事件的发生或等待超时。

在使用Libcurl进行异步请求，从上层结构来看，简单来说，就是对easy handle 和 multi 接口的结合使用。其中，easy handle底层也是一个socket，multi接口，其底层实现也用的是epoll，那么我们如何使用easy handle和multi接口，来实现一个高性能的异步http 请求client呢？下面我们将使用代码的形式，使得读者能够进一步了解其实现机制。

multi 接口的使用是在easy 接口的基础之上，将easy handle放到一个队列中(multi handle)，然后并发发送请求。与easy 接口相比，multi接口是一个异步的，非阻塞的传输方式。

multi接口的使用，主要有以下几个步骤：

  • curl_multi _init初始化一个multi handler对象
  • 初始化多个easy handler对象，使用curl_easy_setopt进行相关设置
  • 调用curl_multi _add_handle把easy handler添加到multi curl对象中
  • 添加完毕后执行curl_multi_perform方法进行并发的访问
  • 访问结束后curl_multi_remove_handle移除相关easy curl对象，先用curl_easy_cleanup清除easy handler对象，最后curl_multi_cleanup清除multi handler对象。

http_request.h

代码语言：javascript复制
/*
该类是对easy handle的封装，主要做一些初始化操作，设置url 、发送的内容
header以及回调函数
*/
class HttpRequest {
public:
  using FinishCallback = std::function<int()>;

  HttpRequest(const std::string& url, const std::string& post_data) :
              url_(url), post_data_(post_data) {
  }
  int Init(const std::vector<std::string> &headers);

  CURL* GetHandle();
  const std::string& Response();

  void SetFinishCallback(const FinishCallback& cb);

  int OnFinish(int response_ret);

  CURLcode Perform();

  void AddMultiHandle(CURLM* multi_handle);

  void Clear(CURLM* multi_handle);

 private:
  void AppendData(char* buffer, size_t size, size_t nmemb);

  static size_t WriteData(char *buffer, size_t size, size_t nmemb, void *userp);

  std::string url_;

  std::string post_data_;

  CURL* handle_ = nullptr;

  struct curl_slist *chunk_ = nullptr;

  FinishCallback cb_;


  int response_ret_;
};

http_request.cc

代码语言：javascript复制
/*http_request.h的实现*/
int HttpRequest::Init(const std::vector<std::string> &headers) {
  handle_ = curl_easy_init();
  if (handle_ == nullptr) {
    return kCurlEasyInitFailed;
  }
  CURLcode ret = curl_easy_setopt(handle_, CURLOPT_URL, url_.c_str());
  if (ret != CURLE_OK) {
    return ret;
  }

  ret = curl_easy_setopt(handle_, CURLOPT_WRITEFUNCTION,
          &HttpRequest::WriteData);
  if (ret != CURLE_OK) {
    return ret;
  }

  ret = curl_easy_setopt(handle_, CURLOPT_WRITEDATA, this);
  if (ret != CURLE_OK) {
    return ret;
  }

  ret = curl_easy_setopt(handle_, CURLOPT_NOSIGNAL, 1);
  if (ret != CURLE_OK) {
    return ret;
  }

  ret = curl_easy_setopt(handle_, CURLOPT_PRIVATE, this);
  if (ret != CURLE_OK) {
    return ret;
  }

  ret = curl_easy_setopt(handle_, CURLOPT_POSTFIELDSIZE, post_data_.length());
  if (ret != CURLE_OK) {
    return ret;
  }
  ret = curl_easy_setopt(handle_, CURLOPT_POSTFIELDS, post_data_.c_str());
  if (ret != CURLE_OK) {
    return ret;
  }

  ret = curl_easy_setopt(handle_, CURLOPT_TIMEOUT_MS, 100);
  if (ret != CURLE_OK) {
    return ret;
  }

//  ret = curl_easy_setopt(handle_, CURLOPT_CONNECTTIMEOUT_MS, 10);

  ret = curl_easy_setopt(handle_, CURLOPT_DNS_CACHE_TIMEOUT,
          600);
  if (ret != CURLE_OK) {
    return ret;
  }

  chunk_ = curl_slist_append(chunk_, "Expect:");

  for (auto item : headers) {
    chunk_ = curl_slist_append(chunk_, item.c_str());
  }


  ret = curl_easy_setopt(handle_, CURLOPT_HTTPHEADER, chunk_);

  if (ret != CURLE_OK) {
    return ret;
  }
  //  设置http header
  if (boost::algorithm::starts_with(url_, "https://")) {
    curl_easy_setopt(handle_, CURLOPT_SSL_VERIFYPEER, false);
    curl_easy_setopt(handle_, CURLOPT_SSL_VERIFYHOST, false);
  }

  return kOk;
}

//获取easy handle
CURL* HttpRequest::GetHandle() {
  return handle_;
}

// 获取http server端的响应
const std::string& HttpRequest::Response() {
  return response_;
}

//设置回调函数，当server返回完成之后，调用
void HttpRequest::SetFinishCallback(const FinishCallback& cb) {
  cb_ = cb;
}

// libcurl 错误码信息
int HttpRequest::OnFinish(int response_ret) {
  response_ret_ = response_ret;

  if (cb_) {
    return cb_();
  }

  return kRequestFinishCallbackNull;
}

// 执行http请求
CURLcode HttpRequest::Perform() {
  CURLcode ret = curl_easy_perform(handle_);
  return ret;
}

// 将easy handle 加入到被监控的multi handle
void HttpRequest::AddMultiHandle(CURLM* multi_handle) {
  if (multi_handle != nullptr) {
    curl_multi_add_handle(multi_handle, handle_);
  }
}

// 释放资源
void HttpRequest::Clear(CURLM* multi_handle) {
  curl_slist_free_all(chunk_);
  if (multi_handle != nullptr) {
    curl_multi_remove_handle(multi_handle, handle_);
  }

  curl_easy_cleanup(handle_);
}

// 获取返回
void HttpRequest::AppendData(char* buffer, size_t size, size_t nmemb) {
  response_.append(buffer, size * nmemb);
}
// 回调函数，获取返回内容
size_t HttpRequest::WriteData(
        char* buffer, size_t size,
        size_t nmemb, void* userp) {
  HttpRequest* req = static_cast<HttpRequest*>(userp);
  req->AppendData(buffer, size, nmemb);
  return size * nmemb;
}

main.cc

代码语言：javascript复制
curl_global_init(CURL_GLOBAL_DEFAULT);
auto multi_handle_ = curl_multi_init();
int numfds = 0;
int running_handles = 0;
while (true) {
  //此处读者来实现,基本功能如下：
  // 1、获取上游的请求内容，从里面获取要发送http的相关信息
  // 2、通过步骤1获取的相关信息，来创建HttpRequest对象
  // 3、将该HttpRequest对象跟multi_handle_对象关联起来
  curl_multi_perform(multi_handle_, &running_handles);
  CURLMcode mc = curl_multi_wait(multi_handle_, nullptr, 0,
            200, &numfds);
    if (mc != CURLM_OK) {
      std::cerr << "RequestDispatcher::Run"
                << " curl_multi_wait failed, ret: "
                << mc;
      continue;
    }
    curl_multi_perform(multi_handle_, &running_handles);

    CURLMsg* msg = nullptr;
    int left = 0;
while ((msg = curl_multi_info_read(multi_handle_, &left))) {
      // msg->msg will always equals to CURLMSG_DONE.
      // CURLMSG_NONE and CURLMSG_LAST were not used.
      if (msg->msg != CURLMSG_DONE) {
        std::cerr << "RequestDispatcher::Run"
                  << " curl_multi_info_read failed, msg: "
                  << msg->msg;
        continue;
      }

      CURL* easy_handle = msg->easy_handle;
      CURLcode curl_ret = msg->data.result;
      int response_ret = kOk;
      if (curl_ret != CURLE_OK) {
        std::cerr << "RequestDispatcher::Run"
                  << " msg->data.result != CURLE_OK, curl_ret: "        
<< curl_ret;
        response_ret = static_cast<int>(curl_ret);
      }

      int http_status_code = 0;
      curl_ret = curl_easy_getinfo(easy_handle,
              CURLINFO_RESPONSE_CODE, &http_status_code);
      if (curl_ret != CURLE_OK) {
        std::cerr << "RequestDispatcher::Run"
                  << " curl_easy_getinfo failed, curl_ret="
                  << curl_ret;
        if (response_ret == kOk) {
          response_ret = static_cast<int>(curl_ret);
        }
      }
      if (http_status_code != 200) {
        std::cerr << "RequestDispatcher::Run"
                  << " http_status_code=" << http_status_code;
        if (response_ret == kOk) {
          response_ret = http_status_code;
        }
      }

      HttpRequest* req = nullptr;
      // In fact curl_easy_getinfo will
      // always return CURLE_OK if CURLINFO_PRIVATE was set.
      curl_ret = curl_easy_getinfo(easy_handle, CURLINFO_PRIVATE, &req);
if (curl_ret != CURLE_OK) {
        std::cerr << "RequestDispatcher::Run"
                  << " curl_easy_getinfo failed, curlf_ret="
                  << curl_ret;
        if (response_ret == kOk) {
          response_ret = static_cast<int>(curl_ret);
        }
      }

      if (req != nullptr) {
        ret = req->OnFinish(response_ret);
      }
    }      
  }

至此，我们已经可以使用libcurl来实现并发发送http请求，当然这个只是一个简单异步实现功能，更多的功能，还需要读者去使用libcurl中的其他功能去实现，此处留给读者一个问题(这个问题，也是笔者项目中使用的一个功能，该项目已经线上稳定运行4年，日请求量在20E

)，业务需要，某一个请求需要并发发送给指定的几家，即该请求，需要并发发送给几个http server，在一个特定的超时时间内，获取这几个http server的返回内容，并进行处理，那么这种功能应该如何使用libcurl来实现呢？透露下，可以使用libcurl的另外一个参数CURLOPT_PRIVATE。

3

性能对比

至此，我们已经基本完成了高性能http 并发功能的设计，那么到底性能如何呢？笔者从 以下几个角度来做了测试：

1、串行发送同步请求

2、多线程情况下，发送同步请求(此处线程为4个，笔者测试的服务器为4C)

3、使用multi接口

4、使用multi接口，并复用其对应的easy handle

5、使用dns cache(对easy handle设置CURLOPT_DNS_CACHE_TIMEOUT)，即不用每次都进行dns解析

方法

平均耗时(ms)

最大耗时(ms)

串行同步

21.381

30.617

多线程同步

4.331

16.751

multi接口

1.376

11.974

multi接口 连接复用

0.352

0.748

multi 接口使用dns cache

0.381

0.731

4

一点心得

libcurl是一个高性能，较易用的HTTP client，在使用其直接，一定要对其接口功能进行详细的了解，否则很容易入坑，犹记得在18年中的时候，上线了某一个功能，会偶现coredump(在上线之前，也进行了大量的性能测试，都没有出现过一次coredump)，为了分析这个原因，笔者将服务的代码一直精简精简，然后模拟测试，缩小coredump定位范围，最终发现，只有在超时的时候，才会导致coredump，这就说明了为什么测试环境没有coredump，而线上会产生coredump，这是因为线上的超时时间设置的是5ms，而测试环境超时时间是20ms，这就基本把原因定位到超时导致的coredump。

然后，分析libcurl源码，发送时一个libcurl的参数设置导致coredump，至此，笔者耗费了23个小时，问题才得以解决。

https 网络安全 ftp ssh php

0 人点赞