利用多线程和 C++ 实现一个简单的 HTTP 服务器
前言：服务器是现代软件不可或缺的一部分，而服务器的技术也是非常复杂和有趣的方向。随着操作系统不断地发展，服务器的底层架构也在不断变化。本文介绍一种使用 C++ 和 多线程实现的简单 HTTP 服务器。
首先我们先来看一下如何创建一个服务器。
int main()
{
int server_fd;
struct sockaddr_in server_addr;
server_fd = socket(AF_INET, SOCK_STREAM, 0);
int on = 1;
setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
if (server_fd < 0) {
perror("create socket error");
goto EXIT;
}
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(8888);
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
perror("bind address error");
goto EXIT;
}
if (listen(server_fd, 511) < 0) {
perror("listen port error");
goto EXIT;
}
while(1) {
int connfd = accept(server_fd, nullptr, nullptr);
if (connfd < 0)
{
perror("accept error");
continue;
}
// 处理
}
close(server_fd);
return 0;
EXIT:
exit(1);
}我们看到根据操作系统提供的 API，创建一个 TCP 服务器非常简单 ，只需要调用几个函数就行。最后进程会阻塞在 accept 等待连接的到来，我们在一个死循环中串行地处理每个请求。显然，这样的效率肯定非常低，因为如果我们使用传统的 read / write 函数的话，它是会引起进程阻塞的，这样就会导致多个请求需要排队进行处理。我们在此基础上利用多线程提高一下效率。
std::thread threads[MAX_THREAD];
std::condition_variable condition_variable;
std::deque<int> requests;
std::mutex mutex;
for (int i = 0; i < MAX_THREAD; i++) {
threads[i] = std::thread(worker, &mutex, &condition_variable, &requests);
}多线程就会涉及到并发 / 同步的问题，所以需要使用互斥变量和条件变量来处理这些问题。上面的代码创建了几个线程，然后在每个线程中执行 worker 函数来处理请求，除此之外，用 requests 变量来表示请求队列，该变量会由主线程和子线程一起访问。具体是由主线程生产任务，子线程消费。在了解子线程逻辑之前先看看主线程代码的改动。
while(1) {
int connfd = accept(server_fd, nullptr, nullptr);
if (connfd < 0)
{
perror("accept error");
continue;
}
{
std::lock_guard<std::mutex> lock(mutex);
requests.push_back(connfd);
condition_variable.notify_one();
}
}我们看到当主线程收到请求时，自己不处理，而是添加到请求队列让子线程处理，因为子线程没有任务处理时会自我阻塞，所以主线程需要唤醒一个线程来处理新的请求。接下来看看子线程的逻辑。
void worker(std::mutex *mutex,
std::condition_variable *condition_variable,
std::deque<int> *requests) {
int connfd;
while (true) {
{
std::unique_lock<std::mutex> lock(*mutex);
// 没有任务则等待，否则取出任务处理
while ((*requests).size() == 0)
{
(*condition_variable).wait(lock);
}
connfd = (*requests).front();
(*requests).pop_front();
}
char buf[4096];
int ret;
while (1) {
memset(buf, 0, sizeof(buf));
int bytes = read(connfd, buf, sizeof(buf));
if (bytes <= 0) {
close(connfd);
} else {
write(connfd, buf, bytes);
}
}
}
}子线程不断从任务队列中取出任务，具体来说就是连接对应的文件描述符，然后不断读取里面的数据，最后返回给客户端。但是这样的功能显然没有太大意义，所以我们基于这个基础上实现一个 HTTP 服务，让它可以处理 HTTP 请求。当然我们手写一个优秀的 HTTP 解析器并非易事，所以我们直接使用开源的就好，这里选择的是 llhttp，这是 Node.js 所使用的 HTTP 解析器。这里就不具体罗列细节，大概介绍一下 llhttp 的用法。
typedef void (*p_on_headers_complete)(on_headers_complete_info, parser_callback);
typedef void (*p_on_body_complete)(on_body_complete_info, parser_callback);
typedef void (*p_on_body)(on_body_info, parser_callback);
struct parser_callback {
void * data;
p_on_headers_complete on_headers_complete;
p_on_body on_body;
p_on_body_complete on_body_complete;
};
class HTTP_Parser {
public:
HTTP_Parser(llhttp_type type, parser_callback callbacks = {});
int on_message_begin(llhttp_t* parser);
int on_status(llhttp_t* parser, const char* at, size_t length);
int on_url(llhttp_t* parser, const char* at, size_t length);
int on_header_field(llhttp_t* parser, const char* at, size_t length);
int on_header_value(llhttp_t* parser, const char* at, size_t length);
int on_headers_complete(llhttp_t* parser);
int on_body(llhttp_t* parser, const char* at, size_t length);
int on_message_complete(llhttp_t* parser);
int parse(const char* data, int len);
int finish();
void print();
};HTTP_Parser 是我自己实现的 HTTP Parser Wrapper，主要是对 llhttp 的封装，我们看到 HTTP_Parser 里有很多回调钩子，对应的就是 llhttp 提供的，另外 HTTP_Parser 支持调用方传入钩子，也就是 parser_callback 所定义的。当 llhttp 回调 HTTP_Parser 时，HTTP_Parser 在合适的时机就会调用 parser_callback 里的回调，比如在解析完 HTTP Header 时，或者解析完整个报文时。具体的解析过程是当调用方收到数据时，执行 parse 函数，然后 llhttp 就会不断地调用我们传入的钩子。了解了 HTTP 解析器的大致使用，我们来看看怎么在项目里使用。
parser_callback callback = {
&connfd,
[](on_body_complete_info info, parser_callback callback) {
int* connfd = (int *)callback.data;
const char * data = "HTTP/1.1 200 OK\r\nServer: multi-thread-server\r\ncontent-length: 11\r\n\r\nhello:world\r\n\r\n";
write(*connfd, data, strlen(data));
close(*connfd);
},
};
HTTP_Parser parser(HTTP_REQUEST, callback);
char buf[4096];
int ret;
while (1) {
memset(buf, 0, sizeof(buf));
int error = 0;
ret = read(connfd, buf, sizeof(buf));
parser.parse(buf, ret);
}这里只列出关键的代码，当我们收到数据时，我们通过 parser.parse(buf, ret) 调用 llhttp 进行解析，llhttp 就会不断地回调钩子函数，当解析完一个报文后，on_body_complete 回调就会被执行，在这里我们就可以对 HTTP 请求进行响应，比如这里返回一个 200 的响应报文，然后关闭连接。因为通过 llhttp 我们可以拿到具体的请求 url，所以我们还可以进一步拓展，根据 url 进行不同的处理。
到此为止，就实现了一个 HTTP 服务器了 ，在早期的时候，服务器也是采用这种多进程 / 多线程的处理方式，现在有了多路复用等技术后，很多服务器都是基于事件驱动来实现了。但是主线程接收请求，分发给子线程处理这种思想在有些服务器也还是存在的，比如 Node.js，只不过 Node.js 中是进程间进行传递。本文大概介绍到这里，服务器技术是非常复杂、有趣的方向，上层的架构也随着操作系统的能力不断在变化，本文只是作一个简单的探索和兴趣罢了，具体代码在 https://github.com/theanarkh/multi-thread-server。下面是架构图。
