Linux 的轻量级多线程 HTTP 服务

      使用基本的Linux系统调用来创建一个TCP socket，监听端口8080，并在接受到客户端连接时创建一个新的线程来处理连接。每个连接处理函数都是一个独立的线程，读取客户端请求并发送固定的HTTP响应。

     代码：

1.  
   #include <iostream>
2.  
   #include <string>
3.  
   #include <cstring>
4.  
   #include <sys/socket.h>
5.  
   #include <arpa/inet.h>
6.  
   #include <unistd.h>
7.  
   #include <pthread.h>
8.  
    
9.  
   const int BUFFER_SIZE = 1024;
10.  
     
11.  
    void *connection_handler(void *socket_desc) {
12.  
    int sock = *(int *)socket_desc;
13.  
    char buffer[BUFFER_SIZE];
14.  
    std::string response = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\nHello, World!";
15.  
     
16.  
    // 读取客户端请求
17.  
    ssize_t read_size = read(sock, buffer, BUFFER_SIZE - 1);
18.  
    if (read_size > 0) {
19.  
    buffer[read_size] = '\0';
20.  
    std::cout << "Received request:\n" << buffer << std::endl;
21.  
     
22.  
    // 发送响应
23.  
    write(sock, response.c_str(), response.length());
24.  
    }
25.  
     
26.  
    // 关闭连接
27.  
    close(sock);
28.  
    delete (int *)socket_desc;
29.  
     
30.  
    return NULL;
31.  
    }
32.  
     
33.  
    int main() {
34.  
    int server_fd, client_sock;
35.  
    struct sockaddr_in server_addr, client_addr;
36.  
    socklen_t addr_len = sizeof(struct sockaddr_in);
37.  
     
38.  
    // 创建 socket
39.  
    server_fd = socket(AF_INET, SOCK_STREAM, 0);
40.  
    if (server_fd == -1) {
41.  
    std::cerr << "Failed to create socket." << std::endl;
42.  
    return 1;
43.  
    }
44.  
     
45.  
    // 设置服务器地址和端口
46.  
    server_addr.sin_family = AF_INET;
47.  
    server_addr.sin_addr.s_addr = INADDR_ANY;
48.  
    server_addr.sin_port = htons(8080);
49.  
     
50.  
    // 绑定地址和端口
51.  
    if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
52.  
    std::cerr << "Failed to bind." << std::endl;
53.  
    return 1;
54.  
    }
55.  
     
56.  
    // 监听连接
57.  
    if (listen(server_fd, 10) < 0) {
58.  
    std::cerr << "Failed to listen." << std::endl;
59.  
    return 1;
60.  
    }
61.  
     
62.  
    std::cout << "Server started. Listening on port 8080..." << std::endl;
63.  
     
64.  
    while (true) {
65.  
    // 接受客户端连接
66.  
    client_sock = accept(server_fd, (struct sockaddr *)&client_addr, &addr_len);
67.  
    if (client_sock < 0) {
68.  
    std::cerr << "Failed to accept connection." << std::endl;
69.  
    continue;
70.  
    }
71.  
     
72.  
    std::cout << "New connection accepted." << std::endl;
73.  
     
74.  
    // 创建线程处理连接
75.  
    pthread_t thread;
76.  
    int *new_sock = new int;
77.  
    *new_sock = client_sock;
78.  
     
79.  
    if (pthread_create(&thread, NULL, connection_handler, (void *)new_sock) < 0) {
80.  
    std::cerr << "Failed to create thread." << std::endl;
81.  
    return 1;
82.  
    }
83.  
     
84.  
    // 分离线程，使其自行释放资源
85.  
    pthread_detach(thread);
86.  
    }
87.  
     
88.  
    // 关闭服务器 socket
89.  
    close(server_fd);
90.  
     
91.  
    return 0;
92.  
    }

代码解析：

这段代码实现了一个简单的基于Linux的轻量级多线程HTTP服务。它的主要逻辑如下：

1. 引入所需的头文件和库：包括iostream（用于输入输出）、string（用于处理字符串）、cstring（用于字符串操作）、sys/socket.h和arpa/inet.h（用于socket编程）、unistd.h（用于关闭连接）和pthread.h（用于多线程编程）。

2. 定义常量和变量：将缓冲区大小定义为BUFFER_SIZE，并声明服务器socket文件描述符(server_fd)和客户端socket文件描述符(client_sock)，以及服务器地址(server_addr)和客户端地址(client_addr)。

3. 创建连接处理函数：定义了一个名为connection_handler的函数，该函数作为每个连接的处理函数。它接受一个void*类型的参数，将其转换为int*类型，表示客户端socket文件描述符。在该函数中，首先从客户端读取请求并打印到控制台，然后向客户端发送固定的HTTP响应。最后关闭客户端socket连接，并释放分配的内存。

4. 主函数：在主函数中，首先创建服务器socket(server_fd)。然后设置服务器地址和端口，并将其与socket绑定。接下来，开始监听连接请求。在一个无限循环中，使用accept函数接受客户端连接，并创建一个新的线程来处理连接。为了能够将客户端socket传递给新线程，使用new运算符动态分配了一个int类型的指针new_sock，并将客户端socket文件描述符赋值给它。然后，使用pthread_create函数创建一个新的线程，将新线程的执行函数设置为connection_handler，并将new_sock作为参数传递给新线程。最后，使用pthread_detach函数将新线程设置为分离状态，使其在完成后自动释放资源。

5. 关闭服务器socket：在无限循环中无法达到的代码，当服务端结束时，关闭服务器socket(server_fd)。

这段代码使用了基本的Linux系统调用和pthread库来实现一个简单的多线程HTTP服务。它接受客户端连接，并为每个连接创建一个独立的线程来处理请求和发送响应。需要注意的是，这只是一个简化的示例，实际的HTTP服务器需要考虑更多的功能和错误处理，例如处理HTTP请求的各种方法、路径解析、错误处理等。

这篇好文章是转载于：学新通技术网