半同步/半反应堆线程池实现简单web服务器
半同步/半反应堆线程池实现简单web服务器，解析http请求
此篇为《linux高性能服务器编程》第15章线程池实例的学习笔记。
半同步/半反应堆线程池模型与进程池模型类似，不过需要考虑使用请求队列，互斥锁来同步线程之间的工作。
locker.h
首先，locker.h文件实现了NPTL线程的三种同步机制的封装。将其封装成对象，便于管理。
#pragma once
/*
此文件是对三种线程同步机制的封装
*/
#ifndef LOCKER_H
#define LOCKER_H
#include threadpool.h
threadpool.h声明了线程池的成员，定义了各个成员函数的逻辑。
#pragma once
#ifndef THREADPOOL_H
#define THREADPOOL_H
#include
#include 代码中比较重要的就是pthread_create传入类静态成员函数的解决方法，因为静态成员函数无法调用动态成员，所以有两种方法解决这个问题：
1.通过类的静态对象来调用，比如单例模式中，维护了一个全局唯一的单例指针实例，可以通过这个实例来调用。
2.像代码中的一样，将类的对象指针this作为参数传给该静态函数，即可通过此指针调用动态成员。
在代码中，worker函数使用了传入的this指针，获取了类的实例，从而调用动态成员。
除此之外，run()函数则是工作线程的主要逻辑，为模板参数类的process()提供计算力。
http_conn.h：模板参数类，实现处理http的逻辑
http_conn类作为传入线程池的模板参数T，需要实现process()函数，以完成对http的解析。
#pragma once
#ifndef HTTPCONNECTION_H
#define HTTPCONNECTION_H
#include 头文件中
bool add_response(const char *format, ...);
bool add_content(const char* content);
bool add_status_line(int status, const char* title);
bool add_content_length(int content_length);
bool add_headers(int content_length);
bool add_linger();
bool add_blank_line();
public:
static int m_epollfd;
static int m_user_count;//统计用户数量
private:
//该http连接的socket
int m_sockfd;
//对法的socket地址
sockaddr_in m_address;
//读缓冲区
char m_read_buf[READ_BUFFER_SIZE];
//读下标地址
int m_read_idx;
//当前正在分析的行的起始位置
int m_check_idx;
//当前正在解析的行的起始地址
int m_start_line;
//写缓冲区
char m_write_buf[WRITE_BUFFER_SIZE];
//写缓冲区下标
int m_write_idx;
//主状态机当前处于的状态，采用有限状态机的思想
CHECK_STATE m_check_state;
//请求方法
METHOD m_method;
//客户请求的目标文件的完整路径，其内容等于doc_root+m_url,doc_root为网站的根目录
char m_real_file[FILENAME_LEN];
//客户请求的目标文件名
char *m_url;
//http协议版本号，支持HTTP/1.1
char *m_version;
//主机名
char *m_host;
//HTTP请求消息体长度
int m_content_length;
//http请求是否要求保持连接
bool m_linger;
//客户请求的目标文件被mmap到内存中的起始位置
char *m_file_address;
//目标文件的状态。判断目标文件是否存在，是否可读可写，并获取目标文件的大小信息。
struct stat m_file_stat;
//我们采用writev函数执行写操作，所以定义下面两个成员，其中m_iv_count表示被写内存块的数量
struct iovec m_iv[2];//将http分为两个连续存储区，一个存储请求头和请求行，一个存储请求体
int m_iv_count;
};
#endif
函数众多，但其实通过分类与梳理，就会发现，private的函数都是为public函数服务的，而public函数就只有5个
-
void init(int sockfd, const sockaddr_in& addr);init()函数初始化了http_conn的连接socket，以及客户端socket地址addr，再通过调用private的init()函数完成其他参数的初始化，如清空缓冲区，初始化m_epollfd等。
-
void close_conn(bool read_close = true);关闭连接，close掉连接socket并释放资源
-
void process();process()函数最为重要，看一下函数主体
//http_conn的工作函数，由线程池中的工作线程调用，这是处理http请求的入口函数 void http_conn::process() { HTTP_CODE read_ret = process_read(); if (read_ret == NO_REQUEST) { //NO_REQUEST表示没有数据，提醒读入事件 modfd(m_epollfd, m_sockfd, EPOLLIN); return; } //根据process_read的请求结果，返回特定的信息，如404，403 bool write_ret = process_write(read_ret); if (!write_ret) { close_conn(); } //成功则说明缓冲区有数据可写，提醒写事件 modfd(m_epollfd, m_sockfd, EPOLLOUT); }我们发现，process()函数调用process_read()函数与process_write()函数，process_read()函数负责读取和解析服务器读取客户发送过来的请求，他调用了一系列解析http的状态机函数，如下：
//解析HTTP请求行，获得请求方法，目标URL，HTTP版本号 HTTP_CODE parse_request_line(char *text); //解析http请求的一个头部信息 HTTP_CODE parse_headers(char *text); //我们没有真正解析HTTP请求的请求体，而是判断他是否被完整读入 HTTP_CODE parse_content(char *text); //do_request进行内存映射 HTTP_CODE do_request(); char *get_line() { return m_read_buf + m_start_line; } //从状态机，从buffer中解析一行http //如果获得完整的行，返回LINE_OK，并从m_read_idx到m_check_idx即为请求行的内容 LINE_STATUS parse_line();这些函数使用有限状态机的思想，读取并解析http请求行，请求头以及请求体，并返回请求结果，我们只需根据请求结果进行process_write()，向客户端反馈即可。
process_write()函数负责将结果反馈给客户端，有以下函数的调用
//c++省略号实现可变参数函数，可通过使用va_list,va_arg等宏定义获取参数，定义在头文件中 bool add_response(const char *format, ...); bool add_content(const char* content); bool add_status_line(int status, const char* title); bool add_content_length(int content_length); bool add_headers(int content_length); bool add_linger(); bool add_blank_line();函数功能即为名字描述，向结果缓冲区中加入一系列字符串即可。
-
bool read();read()函数即时从当前有事件的epollfd上循环读取数据，由process_read函数调用
//循环读取客户数据，直到无数据可读或者对方关闭连接 bool http_conn::read() { if (m_read_idx >= READ_BUFFER_SIZE) { return false; } int bytes_read = 0; while (true) { bytes_read = recv(m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0); if (bytes_read == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK) { continue; } return false; } if (bytes_read == 0) { //有可能关闭连接，也有可能缓冲区冲爆了 return false; } m_read_idx += bytes_read; if (m_read_idx >= READ_BUFFER_SIZE)break; } return true; } -
bool write()write()函数则是向客户端socket写入反馈信息，由process_write函数调用
//写HTTP响应 bool http_conn::write() { int temp = 0; int bytes_have_send = 0; int bytes_to_send = m_write_idx; if (bytes_to_send == 0) { //没东西可写，需要让m_sockfd去读 modfd(m_epollfd, m_sockfd, EPOLLIN); init(); return true; } while (1) { //writev以顺序iov[0]、iov[1]至iov[iovcnt-1]从各缓冲区中聚集输出数据到fd,减少了read和write的系统调用 //readv则相反，将fd的内容一个一个填满iov[0],iov[1]...iov[count-1] temp = writev(m_sockfd, m_iv, m_iv_count); if (temp <= -1) { /* 如果TCP写缓冲区没有空间，则等待下一轮EPOLLOUT事件。虽然在此期间，服务器无法立即接受到同一个客户的下一个请求， 但这样可以保证连接的完整性 */ if (errno == EAGAIN || errno == EWOULDBLOCK) { modfd(m_epollfd, m_sockfd, EPOLLOUT); return true; } unmap(); return false; } bytes_to_send -= temp; bytes_have_send += temp; if (bytes_to_send <= bytes_have_send) { //发送HTTP响应成功，根据HTTP请求中的Connection字段决定是否关闭连接 unmap(); if (m_linger) { init(); modfd(m_epollfd, m_sockfd, EPOLLIN); return true; } else { modfd(m_epollfd, m_sockfd, EPOLLIN); return false; } } } }
http_conn.cpp，实现了http_conn声明的各种函数
/*
此文件为对http_conn.h头文件函数的实现
*/
#include "http_conn.h"
//定义HTTP响应的一些状态信息
const char* ok_200_title = "OK";
const char* error_400_title = "Bad Request";
const char* error_400_form = "Your request has bad syntax or is inherently impossible to satisfy.\n";
const char* error_403_title = "Forbidden";
const char* error_403_form = "You don't have permission to get file from this sever.\n";
const char* error_404_title = "Not Found";
const char* error_404_form = "The request file was not found on this server.\n";
const char* error_500_title = "Internal Error";
const char* error_500_form = "There was an unusual problem serving the requested file.\n";
//网站根目录
const char* doc_root = "/var/www/html";//根据自己情况进行修改
//设置文件描述符为非阻塞
int setnonblocking(int fd) {
int old_option = fcntl(fd, F_GETFL);
int new_option = old_option | O_NONBLOCK;
fcntl(fd, F_SETFL, new_option);
return old_option;
}
//one_shot为EPOLLONESHOT事件
void add_read_fd(int epollfd, int fd,bool one_shot) {
epoll_event event;
event.data.fd = fd;
event.events = EPOLLIN | EPOLLET | EPOLLHUP;
if (one_shot) {
event.events |= EPOLLONESHOT;
}
epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
setnonblocking(fd);
}
void add_write_fd(int epollfd, int fd, bool one_shot) {
epoll_event event;
event.data.fd = fd;
event.events = EPOLLOUT | EPOLLET | EPOLLHUP;
if (one_shot) {
event.events |= EPOLLONESHOT;
}
epoll_ctl(epollfd, EPOLL_CTL_ADD, fd, &event);
setnonblocking(fd);
}
void removefd(int epollfd, int fd) {
epoll_ctl(epollfd, EPOLL_CTL_DEL, fd, 0);
close(fd);
}
//修改事件
void modfd(int epollfd, int fd, int ev) {
epoll_event event;
event.data.fd = fd;
event.events = ev | EPOLLET | EPOLLONESHOT | EPOLLHUP;
epoll_ctl(epollfd, EPOLL_CTL_MOD, fd, &event);
}
int http_conn::m_user_count = 0;
int http_conn::m_epollfd = -1;
void http_conn::close_conn(bool real_close) {
if (real_close && (m_sockfd != -1)) {
removefd(m_epollfd, m_sockfd);
m_sockfd = -1;
m_user_count--;//总连接数-1
}
}
//初始化，addr为client_address，即连接客户端地址，sockfd为连接fd
void http_conn::init(int sockfd, const sockaddr_in& addr) {
m_sockfd = sockfd;
m_address = addr;
//如下两行使用SO_REUSEADDR避免TIME_WAIT状态，仅作为调试时使用，实际使用应当删除
int reuse = 1;
setsockopt(m_sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
add_read_fd(m_epollfd, m_sockfd, true);
m_user_count++;
init();
}
void http_conn::init() {
m_check_state = CHECK_STATE_REQUESTLINE;
//是否保持连接
m_linger = false;
//方法，只支持GET
m_method = GET;
//初始化url
m_url = 0;
//初始化版本
m_version = 0;
m_content_length = 0;
m_host = 0;
m_start_line = 0;
m_check_idx = 0;
m_read_idx = 0;
m_write_idx = 0;
memset(m_read_buf, '\0', sizeof(m_read_buf));
memset(m_write_buf, '\0', sizeof(m_write_buf));
memset(m_real_file, '\0', sizeof(m_real_file));
}
//从状态机，从buffer中解析一行http
//如果获得完整的行，返回LINE_OK，并从m_read_idx到m_check_idx即为请求行的内容
//否则返回LINE_OPEN：表示一行未读取完；LINE_BAD：请求行错误
http_conn::LINE_STATUS http_conn::parse_line() {
char temp;
for (; m_check_idx < m_read_idx; m_check_idx++) {
temp = m_read_buf[m_check_idx];
//http请求行结束的标志是一个回车换行符\r\n
if (temp == '\r') {
if (m_check_idx + 1 == m_read_idx) {
//一行请求没有读完，LINE_OPEN表示请求继续读
return LINE_OPEN;
}
else if (m_read_buf[m_check_idx + 1] == '\n') {
//说明读到了一个完整的行
m_read_buf[m_check_idx++] = '\0';
m_read_buf[m_check_idx++] = '\0';
return LINE_OK;
}
else return LINE_BAD;
}
else if (temp == '\n') {
if (m_check_idx > 1 && m_read_buf[m_check_idx - 1] == '\r') {
m_read_buf[m_check_idx - 1] = '\0';
m_read_buf[m_check_idx++] = '\0';
return LINE_OK;
}
else return LINE_BAD;
}
}
return LINE_OPEN;
}
//循环读取客户数据，直到无数据可读或者对方关闭连接
bool http_conn::read() {
if (m_read_idx >= READ_BUFFER_SIZE) {
return false;
}
int bytes_read = 0;
while (true) {
bytes_read = recv(m_sockfd, m_read_buf + m_read_idx, READ_BUFFER_SIZE - m_read_idx, 0);
if (bytes_read == -1) {
if (errno == EAGAIN || errno == EWOULDBLOCK) {
continue;
}
return false;
}
if (bytes_read == 0) {
//有可能关闭连接，也有可能缓冲区冲爆了
return false;
}
m_read_idx += bytes_read;
if (m_read_idx >= READ_BUFFER_SIZE)break;
}
return true;
}
//解析HTTP请求行，获得请求方法，目标URL，HTTP版本号
http_conn::HTTP_CODE http_conn::parse_request_line(char* text) {
m_url = strpbrk(text, "\t");
if (!m_url) {
return BAD_REQUEST;
}
*m_url++ = '\0';
char* method = text;
if (strcasecmp(method, "GET") == 0) {
m_method = GET;
}
else {
return BAD_REQUEST;
}
m_url += strspn(m_url, "\t");
m_version = strpbrk(m_url, "\t");
if (!m_version) {
return BAD_REQUEST;
}
*m_version++ = '\0';
m_version += strspn(m_version, "\t");
if (strcasecmp(m_version, "HTTP/1.1") != 0) {
return BAD_REQUEST;
}
if (strncasecmp(m_url, "http://", 7) == 0) {
m_url += 7;
m_url = strchr(m_url, '/');
}
if (!m_url || m_url[0] != '/') {
return BAD_REQUEST;
}
m_check_state = CHECK_STATE_HEADER;
return NO_REQUEST;
}
//解析http请求的一个头部信息
//请求头
http_conn::HTTP_CODE http_conn::parse_headers(char* text) {
//遇到空行，表示头部信息处理完毕，接下来是正文
if (text[0] == '\0') {
//如果http请求有消息体，则还需要读取m_content_length字节的消息体
if (m_content_length) {
m_check_state = CHECK_STATE_CONTENT;
return NO_REQUEST;
}
//否则表示没有请求体，http请求处理完成
return GET_REQUEST;
}
//处理Connection头部字段
else if (strncasecmp(text, "Connention:", 11) == 0) {
text += 11;
text += strspn(text, "\t");
if (strcasecmp(text, "keep-alive") == 0) {
m_linger = true;
}
}
//处理Content-Length头部字段
else if (strncasecmp(text, "Content-Length:", strlen("Content-Length:") == 0)) {
text += strlen("Content-Length:");
text += strspn(text, "\t");
m_content_length = atol(text);
}
//处理Host头部字段
else if (strncasecmp(text, "Host:", strlen("Host:")) == 0) {
text += strlen("Host:");
text += strspn(text, "\t");
m_host = text;
}
else {
printf("oops!The server don't know the header!\n");
}
return NO_REQUEST;
}
//我们没有真正解析HTTP请求的请求体，而是判断他是否被完整读入
http_conn::HTTP_CODE http_conn::parse_content(char *text) {
if (m_read_idx >= (m_content_length + m_check_idx)) {
text[m_content_length] = '\0';
return GET_REQUEST;
}
return NO_REQUEST;
}
//主状态机，根据m_check_stat的状态进行转移
/*
CHECK_STATE_CONTENT：表示请求行解析成功，准备解析请求体
CHECK_STATE_REQUESTLINE：表示准备解析请求行，LINE_OK状态只表示行形式正确
CHECK_STATE_HEADER：表示准备解析请求头，必须是请求行解析完成之后
*/
http_conn::HTTP_CODE http_conn::process_read() {
LINE_STATUS line_status = LINE_OK;
HTTP_CODE ret = NO_REQUEST;
char* text = 0;
while (((m_check_state == CHECK_STATE_CONTENT) && (line_status == LINE_OK)) || ((line_status == parse_line()) == LINE_OK)) {
text = get_line();
m_start_line = m_check_idx;
printf("got 1 http line: %s\n", text);
//根据m_check_state进行转移
switch (m_check_state) {
//如果准备解析请求行,调用parse_request_line函数
case CHECK_STATE_REQUESTLINE:
{
ret = parse_request_line(text);
if (ret == BAD_REQUEST) {
return BAD_REQUEST;
}
break;
}
//如果准备解析请求头，调用parse_headers函数
case CHECK_STATE_HEADER: {
ret = parse_headers(text);
if (ret == BAD_REQUEST) {
return BAD_REQUEST;
}
else if (ret == GET_REQUEST) {
//解析完请求头，如果没有请求体，则会返回GET_REQUEST，此时表示http请求已经解析完成，do_request执行
return do_request();
}
break;
}
//如果准备解析请求体，调用parse_content函数
case CHECK_STATE_CONTENT: {
ret = parse_content(text);
if (ret == GET_REQUEST) {
//解析完请求体，返回GET_REQUEST，do_request执行
return do_request();
}
//恢复line_status状态
line_status = LINE_OPEN;
break;
}
default: {
return INTERNAL_ERROR;
}
}
}
return NO_REQUEST;
}
/*
do_request:当得到一个完整的，正确的http请求时，我们需要分析目标文件的属性。如果目标文件存在，对所有用户可读，且不是目录，则使用
mmap将其映射到内存地址m_file_address处，并告诉调用者获取文件成功。
*/
http_conn::HTTP_CODE http_conn::do_request() {
strcpy(m_real_file, doc_root);
int len = strlen(doc_root);
strncpy(m_real_file + len, m_url, FILENAME_LEN - len + 1);
if (stat(m_real_file, &m_file_stat) < 0) {
return NO_REQUEST;
}
if (!(m_file_stat.st_mode & S_IROTH)) {
return FORBIDDEN_REQUEST;
}
if (S_ISDIR(m_file_stat.st_mode)) {
return BAD_REQUEST;
}
int fd=open(m_real_file,O_RDONLY);
m_file_address = (char*)mmap(0, m_file_stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
close(fd);
return FILE_REQUEST;
}
//收回共享内存
void http_conn::unmap() {
if (m_file_address) {
munmap(m_file_address, m_file_stat.st_size);
m_file_address = 0;
}
}
//写HTTP响应
bool http_conn::write() {
int temp = 0;
int bytes_have_send = 0;
int bytes_to_send = m_write_idx;
if (bytes_to_send == 0) {
//没东西可写，需要让m_sockfd去读
modfd(m_epollfd, m_sockfd, EPOLLIN);
init();
return true;
}
while (1) {
//writev以顺序iov[0]、iov[1]至iov[iovcnt-1]从各缓冲区中聚集输出数据到fd,减少了read和write的系统调用
//readv则相反，将fd的内容一个一个填满iov[0],iov[1]...iov[count-1]
temp = writev(m_sockfd, m_iv, m_iv_count);
if (temp <= -1) {
/*
如果TCP写缓冲区没有空间，则等待下一轮EPOLLOUT事件。虽然在此期间，服务器无法立即接受到同一个客户的下一个请求，
但这样可以保证连接的完整性
*/
if (errno == EAGAIN || errno == EWOULDBLOCK) {
modfd(m_epollfd, m_sockfd, EPOLLOUT);
return true;
}
unmap();
return false;
}
bytes_to_send -= temp;
bytes_have_send += temp;
if (bytes_to_send <= bytes_have_send) {
//发送HTTP响应成功，根据HTTP请求中的Connection字段决定是否关闭连接
unmap();
if (m_linger) {
init();
modfd(m_epollfd, m_sockfd, EPOLLIN);
return true;
}
else {
modfd(m_epollfd, m_sockfd, EPOLLIN);
return false;
}
}
}
}
//向写缓冲区中写入待发送的数据，由add_stauts_line,add_content_length等函数调用
//将需要写的请求行，请求头等信息写入缓冲区
bool http_conn::add_response(const char* format, ...) {
if (m_write_idx >= WRITE_BUFFER_SIZE) {
return false;
}
va_list arg_list;//获取省略号的可变参数的内容
va_start(arg_list, format);
//vsnprintf:将格式化数据从可变参数列表写入大小缓冲区
int len = vsnprintf(m_write_buf + m_write_idx, WRITE_BUFFER_SIZE - 1 - m_write_idx, format, arg_list);
if (len >= (WRITE_BUFFER_SIZE - 1 - m_write_idx)) {
return false;
}
m_write_idx += len;
va_end(arg_list);
return true;
}
bool http_conn::add_status_line(int status, const char* title) {
return add_response("%s %d %s\r\n", "HTTP/1.1", status, title);
}
bool http_conn::add_headers(int content_len) {
add_content_length(content_len);
add_linger();
add_blank_line();
}
bool http_conn::add_content_length(int content_len) {
return add_response("Content-Length: %d\r\n", content_len);
}
bool http_conn::add_linger() {
return add_response("Connecetion %s\r\n", (m_linger) ? "keep-alive" : "close" );
}
bool http_conn::add_blank_line() {
return add_response("%s", "\r\n");
}
bool http_conn::add_content(const char * content) {
return add_response("%s", content);
}
//根据服务器处理http请求的结果，决定返回客户端的内容
bool http_conn::process_write(HTTP_CODE ret) {
switch (ret) {
//500服务器内部错误
case INTERNAL_ERROR: {
add_status_line(500, error_500_title);
add_headers(strlen(error_500_form));
if (!add_content(error_500_form)) {
return false;
}
break;
}
//400请求错误
case BAD_REQUEST: {
add_status_line(400, error_400_title);
add_headers(strlen(error_400_form));
if (!add_content(error_400_form)) {
return false;
}
break;
}
//404资源确实，没有响应
case NO_REQUEST: {
add_status_line(404, error_404_title);
add_headers(strlen(error_404_form));
if (!add_content(error_404_form)) {
return false;
}
break;
}
//403禁止访问
case FORBIDDEN_REQUEST: {
add_status_line(403, error_403_title);
add_headers(strlen(error_400_form));
if (!add_content(error_403_form)) {
return false;
}
break;
}
//请求文件成功
case FILE_REQUEST: {
add_status_line(200, ok_200_title);
if (m_file_stat.st_size != 0) {
add_headers(m_file_stat.st_size);
//HTTP响应信息位于m_iv[0]，HTTP请求的文件内容放入m_iv[1]
m_iv[0].iov_base = m_write_buf;
m_iv[0].iov_len = m_write_idx;
m_iv[1].iov_base = m_file_address;
m_iv[1].iov_len = m_file_stat.st_size;
m_iv_count = 2;
return true;
}
else {
const char* ok_string = "";
add_headers(strlen(ok_string));
if (!add_content(ok_string)) {
return false;
}
}
}
default: {
return true;
}
}
m_iv[0].iov_base = m_write_buf;
m_iv[0].iov_len = m_write_idx;
m_iv_count = 1;
return true;
}
//http_conn的工作函数，由线程池中的工作线程调用，这是处理http请求的入口函数
void http_conn::process() {
HTTP_CODE read_ret = process_read();
if (read_ret == NO_REQUEST) {
//NO_REQUEST表示没有数据，提醒读入事件
modfd(m_epollfd, m_sockfd, EPOLLIN);
return;
}
//根据process_read的请求结果，返回特定的信息，如404，403
bool write_ret = process_write(read_ret);
if (!write_ret) {
close_conn();
}
//成功则说明缓冲区有数据可写，提醒写事件
modfd(m_epollfd, m_sockfd, EPOLLOUT);
}
main.cpp，为主线程的逻辑
在main.cpp中，主线程使用epoll进行io复用操作，将一个个连接任务分发给线程池中的工作线程处理（半同步/半反应堆模型），工作模式和半同步/半异步进程池大致相同，不在赘述。
#include 总结
最后整理一下，整个半同步/半反应堆线程池逻辑流程如下：
- 主线程创建线程池，完成初始化监听fd，绑定socket地址，创建epollfd等一系列操作
- 主线程通过epoll循环获取事件，根据事件不同做不同处理
- 如果是新连接（listenfd上的事件），则初始化新的http_conn对象，获取客户端地址
- 如果是读事件（EPOLLIN），则调用对应sockfd的http_conn对象，进行数据读取（read()函数），read函数则会解析http并将结果写入写缓冲区中
- 如果是写事件（EPOLLOUT），则调用对应sockfd的http_conn对象，进行数据写（write()函数）,write函数则会将写缓冲区的数据反馈客户端。