devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++ 网络库：libevent、libev、libuv、poco、libhv、asi、ace、QUIC 协议_c++网络库

作者：知新_RL | 2024-05-08 10:39:47

赞

踩

c++网络库

From：https://zhuanlan.zhihu.com/p/357075167

1、各编程语言HTTP请求对比

java、c#、go、ruby 都有内置的net包，此外各语言都有各自流行的网络库、HTTP请求库、HTTP脚手架和 web 框架。

  • java 有 netty、OKHttp、tomcat、SpringBoot、SpringCloud
  • c# 有 RestSharp、Nancy
  • go 有 gin、iris、beego
  • python 有 urllib、requests、flask、Django
  • ruby 有 faraday、httparty、rails
  • php 有 thinkphp、laravel
  • js 有 ajax、axios、express、koa
  • c 有 curl

下面的 HTTP 请求代码均 copy 自 postman，postman 列举了众多语言写法，独独没有C++。

c: libcurl

libcurl：https://curl.se/libcurl/

curl作为命令行工具确实简单好用，比wget更强大。当被作为库使用，并不也是那么简单，往往需要自己动手再封装一层。当然这也是c语言的通病，为了复用同一个接口，导致接口很难用。

  1. CURL *hnd = curl_easy_init();
  2.  
  3. curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
  4. curl_easy_setopt(hnd, CURLOPT_URL, "http://127.0.0.1:8080/echo");
  5.  
  6. struct curl_slist *headers = NULL;
  7. headers = curl_slist_append(headers, "content-type: application/json");
  8. curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
  9.  
  10. curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\"key\":\"value\"}");
  11.  
  12. CURLcode ret = curl_easy_perform(hnd);

上面的代码仅仅只是请求部分，想要获取响应内容，还得设置回调函数并在回调里解析数据：

  1. curl_easy_setopt(curl, CURLOPT_HEADER, 0);
  2. curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, header_cb);
  3. curl_easy_setopt(curl, CURLOPT_HEADERDATA, header_userdata);
  4.  
  5. curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, body_cb);
  6. curl_easy_setopt(curl, CURLOPT_WRITEDATA, body_userdata);

curl_easy尚且如此繁琐，curl_multi更加让人望而却步。

c#: RestSharp

  1. var client = new RestClient("http://127.0.0.1:8080/echo");
  2. var request = new RestRequest(Method.POST);
  3. request.AddHeader("content-type", "application/json");
  4. request.AddParameter("application/json", "{\"key\":\"value\"}", ParameterType.RequestBody);
  5. IRestResponse response = client.Execute(request);

go: net/http

  1. package main
  2.  
  3. import (
  4.     "fmt"
  5.     "strings"
  6.     "net/http"
  7.     "io/ioutil"
  8. )
  9.  
  10. func main() {
  11.     url := "http://127.0.0.1:8080/echo"
  12.  
  13.     payload := strings.NewReader("{\"key\":\"value\"}")
  14.  
  15.     req, _ := http.NewRequest("POST", url, payload)
  16.  
  17.     req.Header.Add("content-type", "application/json")
  18.  
  19.     res, _ := http.DefaultClient.Do(req)
  20.  
  21.     defer res.Body.Close()
  22.     body, _ := ioutil.ReadAll(res.Body)
  23.  
  24.     fmt.Println(res)
  25.     fmt.Println(string(body))
  26. }

java: OKHttp

  1. OkHttpClient client = new OkHttpClient();
  2.  
  3. MediaType mediaType = MediaType.parse("application/json");
  4. RequestBody body = RequestBody.create(mediaType, "{\"key\":\"value\"}");
  5. Request request = new Request.Builder()
  6.   .url("http://127.0.0.1:8080/echo")
  7.   .post(body)
  8.   .addHeader("content-type", "application/json")
  9.   .build();
  10.  
  11. Response response = client.newCall(request).execute();

php: HttpRequest

  1. <?php
  2.  
  3. $request = new HttpRequest();
  4. $request->setUrl('http://127.0.0.1:8080/echo');
  5. $request->setMethod(HTTP_METH_POST);
  6.  
  7. $request->setHeaders(array(
  8.   'content-type' => 'application/json'
  9. ));
  10.  
  11. $request->setBody('{"key":"value"}');
  12.  
  13. try {
  14.   $response = $request->send();
  15.  
  16.   echo $response->getBody();
  17. } catch (HttpException $ex) {
  18.   echo $ex;
  19. }

python: requests

  1. import requests
  2.  
  3. url = "http://127.0.0.1:8080/echo"
  4.  
  5. payload = "{\"key\":\"value\"}"
  6. headers = {
  7.     'content-type': "application/json"
  8.     }
  9.  
  10. response = requests.request("POST", url, data=payload, headers=headers)
  11.  
  12. print(response.text)

ruby: net/http

  1. require 'uri'
  2. require 'net/http'
  3.  
  4. url = URI("http://127.0.0.1:8080/echo")
  5.  
  6. http = Net::HTTP.new(url.host, url.port)
  7.  
  8. request = Net::HTTP::Post.new(url)
  9. request["content-type"] = 'application/json'
  10. request.body = "{\"key\":\"value\"}"
  11.  
  12. response = http.request(request)
  13. puts response.read_body

nodejs: http

  1. var http = require("http");
  2.  
  3. var options = {
  4.   "method": "POST",
  5.   "hostname": "127.0.0.1",
  6.   "port": "8080",
  7.   "path": "/echo",
  8.   "headers": {
  9.     "content-type": "application/json"
  10.   }
  11. };
  12.  
  13. var req = http.request(options, function (res) {
  14.   var chunks = [];
  15.  
  16.   res.on("data", function (chunk) {
  17.     chunks.push(chunk);
  18.   });
  19.  
  20.   res.on("end", function () {
  21.     var body = Buffer.concat(chunks);
  22.     console.log(body.toString());
  23.   });
  24. });
  25.  
  26. req.write(JSON.stringify({ key: 'value' }));
  27. req.end();

对比结论

  • 动态语言比静态语言更简单灵活；
  • 有反射机制的语言比无反射机制的语言更简单灵活；
  • c语言没有string、map、反射、ORM，写复杂应用层协议简直就是找虐，更别说写数据库应用了。如不分场合，强行使用c/c++写web应用，开发效率注定感人，可能人家已经开始展示各种炫酷图表了，你还在那解析字符串。

2、C/C++ 网络库对比

以TCP Echo Server为例，展示各个网络库的写法。

代码：https://github.com/ithewei/libhv/tree/master/echo-servers

libevent

libevent：http://libevent.org/

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. #include "event2/event.h"
  6. #include "event2/listener.h"
  7. #include "event2/bufferevent.h"
  8. #include "event2/buffer.h"
  9.  
  10. //#define RECV_BUFSIZE    8192
  11.  
  12. void error_cb(struct bufferevent* bev, short event, void* userdata) {
  13.     bufferevent_free(bev);
  14. }
  15.  
  16. void read_cb(struct bufferevent* bev, void* userdata) {
  17.     //static char recvbuf[RECV_BUFSIZE];
  18.     //int nread = bufferevent_read(bev, &recvbuf, RECV_BUFSIZE);
  19.     //bufferevent_write(bev, recvbuf, nread);
  20.     struct evbuffer* buf = evbuffer_new();
  21.     int ret = bufferevent_read_buffer(bev, buf);
  22.     if (ret == 0) {
  23.         bufferevent_write_buffer(bev, buf);
  24.     }
  25.     evbuffer_free(buf);
  26. }
  27.  
  28. void on_accept(struct evconnlistener* listener, evutil_socket_t connfd, struct sockaddr* peeraddr, int addrlen, void* userdata) {
  29.     struct event_base* loop = evconnlistener_get_base(listener);
  30.     struct bufferevent* bev = bufferevent_socket_new(loop, connfd, BEV_OPT_CLOSE_ON_FREE);
  31.     bufferevent_setcb(bev, read_cb, NULL, error_cb, NULL);
  32.     bufferevent_enable(bev, EV_READ|EV_WRITE|EV_PERSIST);
  33. }
  34.  
  35. int main(int argc, char** argv) {
  36.     if (argc < 2) {
  37.         printf("Usage: cmd port\n");
  38.         return -10;
  39.     }
  40.     int port = atoi(argv[1]);
  41.  
  42.     struct event_base* loop = event_base_new();
  43.  
  44.     struct sockaddr_in addr;
  45.     memset(&addr, 0, sizeof(addr));
  46.     addr.sin_family = AF_INET;
  47.     addr.sin_port = htons(port);
  48.     struct evconnlistener* listener =  evconnlistener_new_bind(
  49.             loop, on_accept, NULL,
  50.             LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_FREE,
  51.             -1, (struct sockaddr*)&addr, sizeof(addr));
  52.     if (listener == NULL) {
  53.         return -20;
  54.     }
  55.  
  56.     event_base_dispatch(loop);
  57.  
  58.     evconnlistener_free(listener);
  59.     event_base_free(loop);
  60.     return 0;
  61. }
  • 优点：历史最为悠久，有不少著名项目背书(包括memcached、libwebsockets、360的evpp)，稳定性有保障；
  • 缺点：libevent 最为古老、有历史包袱，bufferevent 虽为精妙，却也难以上手；

libev

libev：http://software.schmorp.de/pkg/libev.html

  1. #include <unistd.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5.  
  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <netinet/in.h>
  9.  
  10. #include "ev.h"
  11.  
  12. #define RECV_BUFSIZE    8192
  13. static char recvbuf[RECV_BUFSIZE];
  14.  
  15. void do_recv(struct ev_loop *loop, struct ev_io *io, int revents) {
  16.     int nread, nsend;
  17.     nread = recv(io->fd, recvbuf, RECV_BUFSIZE, 0);
  18.     if (nread <= 0) {
  19.         goto error;
  20.     }
  21.     nsend = send(io->fd, recvbuf, nread, 0);
  22.     if (nsend != nread) {
  23.         goto error;
  24.     }
  25.     return;
  26.  
  27. error:
  28.     ev_io_stop(loop, io);
  29.     close(io->fd);
  30.     free(io);
  31. }
  32.  
  33. void do_accept(struct ev_loop *loop, struct ev_io *listenio, int revents) {
  34.     struct sockaddr_in peeraddr;
  35.     socklen_t addrlen = sizeof(peeraddr);
  36.     int connfd = accept(listenio->fd, (struct sockaddr*)&peeraddr, &addrlen);
  37.     if (connfd <= 0) {
  38.         return;
  39.     }
  40.  
  41.     struct ev_io* io = (struct ev_io*)malloc(sizeof(struct ev_io));
  42.     ev_io_init(io, do_recv, connfd, EV_READ);
  43.     ev_io_start(loop, io);
  44. }
  45.  
  46. int main(int argc, char** argv) {
  47.     if (argc < 2) {
  48.         printf("Usage: cmd port\n");
  49.         return -10;
  50.     }
  51.     int port = atoi(argv[1]);
  52.  
  53.     struct sockaddr_in addr;
  54.     int addrlen = sizeof(addr);
  55.     memset(&addr, 0, addrlen);
  56.     addr.sin_family = AF_INET;
  57.     addr.sin_port = htons(port);
  58.     int listenfd = socket(AF_INET, SOCK_STREAM, 0);
  59.     if (listenfd < 0) {
  60.         return -20;
  61.     }
  62.     if (bind(listenfd, (struct sockaddr*)&addr, addrlen) < 0) {
  63.         return -30;
  64.     }
  65.     if (listen(listenfd, SOMAXCONN) < 0) {
  66.         return -40;
  67.     }
  68.  
  69.     struct ev_loop* loop = ev_loop_new(0);
  70.  
  71.     struct ev_io listenio;
  72.     ev_io_init(&listenio, do_accept, listenfd, EV_READ);
  73.     ev_io_start(loop, &listenio);
  74.  
  75.     ev_run(loop, 0);
  76.     ev_loop_destroy(loop);
  77.     return 0;
  78. }

优点：libev可以说是libevent的精简版，库源码极为短小精悍，不到八千行;

缺点：

  • 库源码中定义了大量的宏，想读懂需要扎实的c功底；
  • 封装层次较低，如监听端口，需要老老实实手写socket->bind->listen这个流程；
  • IO事件只是通知你可读可写，需要自行调用recv/send；
  • windows平台实现不佳；

libuv

  1. #define _GNU_SOURCE 1
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5.  
  6. #include "uv.h"
  7.  
  8. typedef struct {
  9.     uv_write_t  req;
  10.     uv_buf_t    buf;
  11. } uv_write_req_t;
  12.  
  13. void alloc_cb(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
  14.     buf->base = (char*)malloc(suggested_size);
  15.     buf->len = suggested_size;
  16. }
  17.  
  18. void close_cb(uv_handle_t* handle) {
  19.     free(handle);
  20. }
  21.  
  22. void write_cb(uv_write_t* req, int status) {
  23.     uv_write_req_t* wr = (uv_write_req_t*)req;
  24.     free(wr->buf.base);
  25.     free(wr);
  26. }
  27.  
  28. void read_cb(uv_stream_t* stream, ssize_t nread, const uv_buf_t* buf) {
  29.     if (nread <= 0) {
  30.         uv_close((uv_handle_t*)stream, close_cb);
  31.         return;
  32.     }
  33.     uv_write_req_t* wr = (uv_write_req_t*)malloc(sizeof(uv_write_req_t));
  34.     wr->buf.base = buf->base;
  35.     wr->buf.len = nread;
  36.     uv_write(&wr->req, stream, &wr->buf, 1, write_cb);
  37. }
  38.  
  39. void do_accept(uv_stream_t* server, int status) {
  40.     uv_tcp_t* tcp_stream = (uv_tcp_t*)malloc(sizeof(uv_tcp_t));
  41.     uv_tcp_init(server->loop, tcp_stream);
  42.     uv_accept(server, (uv_stream_t*)tcp_stream);
  43.     uv_read_start((uv_stream_t*)tcp_stream, alloc_cb, read_cb);
  44. }
  45.  
  46. int main(int argc, char** argv) {
  47.     if (argc < 2) {
  48.         printf("Usage: cmd port\n");
  49.         return -10;
  50.     }
  51.     int port = atoi(argv[1]);
  52.  
  53.     uv_loop_t loop;
  54.     uv_loop_init(&loop);
  55.  
  56.     struct sockaddr_in addr;
  57.     memset(&addr, 0, sizeof(addr));
  58.     //addr.sin_family = AF_INET;
  59.     //addr.sin_port = htons(port);
  60.     uv_ip4_addr("0.0.0.0", port, &addr);
  61.  
  62.     uv_tcp_t tcp_server;
  63.     uv_tcp_init(&loop, &tcp_server);
  64.     int ret = uv_tcp_bind(&tcp_server, (struct sockaddr*)&addr, 0);
  65.     if (ret) {
  66.         return -20;
  67.     }
  68.     ret = uv_listen((uv_stream_t*)&tcp_server, SOMAXCONN, do_accept);
  69.     if (ret) {
  70.         return -30;
  71.     }
  72.  
  73.     uv_run(&loop, UV_RUN_DEFAULT);
  74.     return 0;
  75. }

优点：

  • nodejs的底层库，有nodejs这个大佬背书，稳定性、性能都毋庸置疑；
  • 命名很清晰，统一以uv_前缀开头;
  • 功能很强大，同时支持管道、文件的异步读写；

缺点：

  • 封装的结构体比较多，有一定的上手学习成本；
  • 监听端口还是需要uv_ip4_addr->uv_tcp_bind->uv_listen这一套流程；
  • 没有提供读写buffer，uv_read_start/uv_write需要自己申请和释放内存，往往需要结合自己的业务实现一个内存池，不然每次读写都直接malloc/free，在某些操作系统上可能有性能损耗和内存碎片问题；

POCO

POCO：http://pocoproject.org/

POCO 用户手册、示例：https://docs.pocoproject.org/current/

POCO C++库入门指南：https://blog.csdn.net/danlan_shiguang/article/details/124419814

libhv ( 国产网络库 )

比 libevent、libuv 更易用的国产网络库：github：https://github.com/ithewei/libhv

c 版本：

  1. #include "hv/hloop.h"
  2.  
  3. void on_close(hio_t* io) {
  4. }
  5.  
  6. void on_recv(hio_t* io, void* buf, int readbytes) {
  7.     hio_write(io, buf, readbytes);
  8. }
  9.  
  10. void on_accept(hio_t* io) {
  11.     hio_setcb_close(io, on_close);
  12.     hio_setcb_read(io, on_recv);
  13.     hio_read(io);
  14. }
  15.  
  16. int main(int argc, char** argv) {
  17.     if (argc < 2) {
  18.         printf("Usage: cmd port\n");
  19.         return -10;
  20.     }
  21.     int port = atoi(argv[1]);
  22.  
  23.     hloop_t* loop = hloop_new(0);
  24.     hio_t* listenio = hloop_create_tcp_server(loop, "0.0.0.0", port, on_accept);
  25.     if (listenio == NULL) {
  26.         return -20;
  27.     }
  28.     hloop_run(loop);
  29.     hloop_free(&loop);
  30.     return 0;
  31. }

c++版本：

  1. #include "hv/TcpServer.h"
  2.  
  3. using namespace hv;
  4.  
  5. int main(int argc, char* argv[]) {
  6.     if (argc < 2) {
  7.         printf("Usage: %s port\n", argv[0]);
  8.         return -10;
  9.     }
  10.     int port = atoi(argv[1]);
  11.  
  12.     TcpServer srv;
  13.     int listenfd = srv.createsocket(port);
  14.     if (listenfd < 0) {
  15.         return -20;
  16.     }
  17.     printf("server listen on port %d, listenfd=%d ...\n", port, listenfd);
  18.     srv.onConnection = [](const SocketChannelPtr& channel) {
  19.         std::string peeraddr = channel->peeraddr();
  20.         if (channel->isConnected()) {
  21.             printf("%s connected! connfd=%d\n", peeraddr.c_str(), channel->fd());
  22.         } else {
  23.             printf("%s disconnected! connfd=%d\n", peeraddr.c_str(), channel->fd());
  24.         }
  25.     };
  26.     srv.onMessage = [](const SocketChannelPtr& channel, Buffer* buf) {
  27.         // echo
  28.         printf("< %.*s\n", (int)buf->size(), (char*)buf->data());
  29.         channel->write(buf);
  30.     };
  31.     srv.onWriteComplete = [](const SocketChannelPtr& channel, Buffer* buf) {
  32.         printf("> %.*s\n", (int)buf->size(), (char*)buf->data());
  33.     };
  34.     srv.setThreadNum(4);
  35.     srv.start();
  36.  
  37.     while (1) sleep(1);
  38.     return 0;
  39. }

优点：

  • libhv本身是参考了libevent、libev、libuv的实现思路，它们的核心都是事件循环（即在一个事件循环中处理IO、定时器等事件），没有历史包袱，去其糟粕，取其精华；
  • 提供的接口最为精简，API接近原生系统调用，最容易上手；
  • 提供了c++的封装，参考了muduo和evpp;
  • 支持心跳、转发、拆包、多线程安全write和close等特性;
  • 原生支持SSL/TLS;
  • 提供了HTTP脚手架;
  • 支持WebSocket协议;
  • 支持 MQTT协议
  • 未来将支持更多的常见协议，如redis、kafka、mysql;
  • 国产开源库，有中文教程，有QQ技术交流群(739352073)可供寻求技术支持;

asio

asio有C++11版本，不依赖boost。Asio：http://think-async.com/

  1. #include <cstdlib>
  2. #include <iostream>
  3. #include <boost/bind.hpp>
  4. #include <boost/asio.hpp>
  5.  
  6. using boost::asio::ip::tcp;
  7.  
  8. class session {
  9. public:
  10.     session(boost::asio::io_service& io_service) :
  11.         socket_(io_service) {
  12.     }
  13.  
  14.     tcp::socket& socket() {
  15.         return socket_;
  16.     }
  17.  
  18.     void start() {
  19.         socket_.async_read_some(boost::asio::buffer(data_, max_length),
  20.                 boost::bind(&session::handle_read, this,
  21.                         boost::asio::placeholders::error,
  22.                         boost::asio::placeholders::bytes_transferred));
  23.     }
  24.  
  25.     void handle_read(const boost::system::error_code& error,
  26.             size_t bytes_transferred) {
  27.         if (!error) {
  28.             boost::asio::async_write(socket_, boost::asio::buffer(data_,
  29.                     bytes_transferred), boost::bind(&session::handle_write,
  30.                     this, boost::asio::placeholders::error));
  31.         } else {
  32.             delete this;
  33.         }
  34.     }
  35.  
  36.     void handle_write(const boost::system::error_code& error) {
  37.         if (!error) {
  38.             socket_.async_read_some(boost::asio::buffer(data_, max_length),
  39.                     boost::bind(&session::handle_read, this,
  40.                             boost::asio::placeholders::error,
  41.                             boost::asio::placeholders::bytes_transferred));
  42.         } else {
  43.             delete this;
  44.         }
  45.     }
  46.  
  47. private:
  48.     tcp::socket socket_;
  49.     enum {
  50.         max_length = 1024
  51.     };
  52.     char data_[max_length];
  53. };
  54.  
  55. class server {
  56. public:
  57.     server(boost::asio::io_service& io_service, short port) :
  58.         io_service_(io_service), acceptor_(io_service, tcp::endpoint(tcp::v4(),
  59.                 port)) {
  60.         session* new_session = new session(io_service_);
  61.         acceptor_.async_accept(new_session->socket(), boost::bind(
  62.                 &server::handle_accept, this, new_session,
  63.                 boost::asio::placeholders::error));
  64.     }
  65.  
  66.     void handle_accept(session* new_session,
  67.             const boost::system::error_code& error) {
  68.         if (!error) {
  69.             new_session->start();
  70.             new_session = new session(io_service_);
  71.             acceptor_.async_accept(new_session->socket(), boost::bind(
  72.                     &server::handle_accept, this, new_session,
  73.                     boost::asio::placeholders::error));
  74.         } else {
  75.             delete new_session;
  76.         }
  77.     }
  78.  
  79. private:
  80.     boost::asio::io_service& io_service_;
  81.     tcp::acceptor acceptor_;
  82. };
  83.  
  84. int main(int argc, char** argv) {
  85.     if (argc < 2) {
  86.         printf("Usage: cmd port\n");
  87.         return -10;
  88.     }
  89.     int port = atoi(argv[1]);
  90.  
  91.     boost::asio::io_service io_service;
  92.     server s(io_service, port);
  93.     io_service.run();
  94.  
  95.     return 0;
  96. }

优点：

  • 曾被提名标准网络库，可惜boost不能整体入标准库，asio自然也不得成神;
  • 极具争议，赞者骂者参半
  • beast支持HTTP和WebSocket;
  • websocketpp支持WebSocket协议；

ACE

ACE：https://github.com/cflowe/ACE

ACE也是很经典的网络库，出自《C++网络编程》作者之手，设计精妙程度堪称一流，支持协议范围也很广，但是使用复杂度和学习复杂度较高，一直有“学我者生，用我者死”的评价。

总结

  • aio 是linux2.6以后内核实现的异步IO，或者说他才是真正意义上的异步IO。
  • epoll作为select的linux的替代品，解决了selectfd_set的限制。性能优于select。而在mac os x平台上替代方案是kqueue。
  • libevent是一个跨平台异步解决方案，他根据不同的平台提供了不同的异步方案，采用Reactor模型实现。
  • Boost::asio是一个跨平台的网络及底层IO的C++编程库，实现了对TCP、UDP、ICMP、串口的支持。对于读写方式，ASIO支持同步和异步两种方式。采用了epoll来实现，插入了大量的信号处理。Asio库不需要单独便于，但是测试过程中对boost::system的依赖可能会需要编译部分boost中的库。
  • muduo采用Reactor模型实现的网络库，只支持Linux 2.6.x下的并发非阻塞TCP网络编程，不跨平台，不支持udp和ipv6。吞吐量方面muduo比libevent2快18%，在事件处理效率方面，muduo与libevent2总体比较接近，muduo吞吐量比boost.asio高15%以上。性能方面作为解决大数据吞吐量很有优势，但是对平台和网络协议支持方面是一个问题。
  • aio 和 epoll 主要是对异步提供解决方案，不是网络库不提供网络支持。而 libevent 也是主要解决 IO 的问题但是只提供简单的http支持。asio 和 muduo 还有 ACE 一样是高性能网络库。

3、QUIC 协议

QUIC 全称：Quick UDP Internet Connections，是一种基于 UDP 的传输层协议。由 Google 自研，2012 年部署上线，2013 年提交 IETF，2021 年 5 月，IETF 推出标准版 RFC9000。

QUIC协议是传输层 "更快、更稳、更高效" 的网络通信协议。

QUIC 协议是在 UDP 的基础之上，集成了 TCP 的可靠传输特性，集成了 TLS1.3 协议，保证了用户数据传输的安全。

QUIC 协议详解

：https://zhuanlan.zhihu.com/p/405387352

一文读懂 QUIC 协议

：https://zhuanlan.zhihu.com/p/655070575

传输层协议：QUIC

：https://cloud.tencent.com/developer/article/2336551

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/554116
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号