利用多線程和 C++ 實現(xiàn)一個簡單的 HTTP 服務(wù)器
前言：服務(wù)器是現(xiàn)代軟件不可或缺的一部分，而服務(wù)器的技術(shù)也是非常復(fù)雜和有趣的方向。隨著操作系統(tǒng)不斷地發(fā)展，服務(wù)器的底層架構(gòu)也在不斷變化。本文介紹一種使用 C++ 和 多線程實現(xiàn)的簡單 HTTP 服務(wù)器。
首先我們先來看一下如何創(chuàng)建一個服務(wù)器。
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);
}
我們看到根據(jù)操作系統(tǒng)提供的 API，創(chuàng)建一個 TCP 服務(wù)器非常簡單 ，只需要調(diào)用幾個函數(shù)就行。最后進程會阻塞在 accept 等待連接的到來，我們在一個死循環(huán)中串行地處理每個請求。顯然，這樣的效率肯定非常低，因為如果我們使用傳統(tǒng)的 read / write 函數(shù)的話，它是會引起進程阻塞的，這樣就會導(dǎo)致多個請求需要排隊進行處理。我們在此基礎(chǔ)上利用多線程提高一下效率。
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);
}
多線程就會涉及到并發(fā) / 同步的問題，所以需要使用互斥變量和條件變量來處理這些問題。上面的代碼創(chuàng)建了幾個線程，然后在每個線程中執(zhí)行 worker 函數(shù)來處理請求，除此之外，用 requests 變量來表示請求隊列，該變量會由主線程和子線程一起訪問。具體是由主線程生產(chǎn)任務(wù)，子線程消費。在了解子線程邏輯之前先看看主線程代碼的改動。
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();
}
}
我們看到當主線程收到請求時，自己不處理，而是添加到請求隊列讓子線程處理，因為子線程沒有任務(wù)處理時會自我阻塞，所以主線程需要喚醒一個線程來處理新的請求。接下來看看子線程的邏輯。
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);
// 沒有任務(wù)則等待，否則取出任務(wù)處理
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);
}
}
}
}
子線程不斷從任務(wù)隊列中取出任務(wù)，具體來說就是連接對應(yīng)的文件描述符，然后不斷讀取里面的數(shù)據(jù)，最后返回給客戶端。但是這樣的功能顯然沒有太大意義，所以我們基于這個基礎(chǔ)上實現(xiàn)一個 HTTP 服務(wù)，讓它可以處理 HTTP 請求。當然我們手寫一個優(yōu)秀的 HTTP 解析器并非易事，所以我們直接使用開源的就好，這里選擇的是 llhttp，這是 Node.js 所使用的 HTTP 解析器。這里就不具體羅列細節(jié)，大概介紹一下 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 是我自己實現(xiàn)的 HTTP Parser Wrapper，主要是對 llhttp 的封裝，我們看到 HTTP_Parser 里有很多回調(diào)鉤子，對應(yīng)的就是 llhttp 提供的，另外 HTTP_Parser 支持調(diào)用方傳入鉤子，也就是 parser_callback 所定義的。當 llhttp 回調(diào) HTTP_Parser 時，HTTP_Parser 在合適的時機就會調(diào)用 parser_callback 里的回調(diào)，比如在解析完 HTTP Header 時，或者解析完整個報文時。具體的解析過程是當調(diào)用方收到數(shù)據(jù)時，執(zhí)行 parse 函數(shù)，然后 llhttp 就會不斷地調(diào)用我們傳入的鉤子。了解了 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);
}
這里只列出關(guān)鍵的代碼，當我們收到數(shù)據(jù)時，我們通過 parser.parse(buf, ret) 調(diào)用 llhttp 進行解析，llhttp 就會不斷地回調(diào)鉤子函數(shù)，當解析完一個報文后，on_body_complete 回調(diào)就會被執(zhí)行，在這里我們就可以對 HTTP 請求進行響應(yīng)，比如這里返回一個 200 的響應(yīng)報文，然后關(guān)閉連接。因為通過 llhttp 我們可以拿到具體的請求 url，所以我們還可以進一步拓展，根據(jù) url 進行不同的處理。
到此為止，就實現(xiàn)了一個 HTTP 服務(wù)器了 ，在早期的時候，服務(wù)器也是采用這種多進程 / 多線程的處理方式，現(xiàn)在有了多路復(fù)用等技術(shù)后，很多服務(wù)器都是基于事件驅(qū)動來實現(xiàn)了。但是主線程接收請求，分發(fā)給子線程處理這種思想在有些服務(wù)器也還是存在的，比如 Node.js，只不過 Node.js 中是進程間進行傳遞。本文大概介紹到這里，服務(wù)器技術(shù)是非常復(fù)雜、有趣的方向，上層的架構(gòu)也隨著操作系統(tǒng)的能力不斷在變化，本文只是作一個簡單的探索和興趣罷了，具體代碼在 https://github.com/theanarkh/multi-thread-server。下面是架構(gòu)圖。
