【从0开始编写webserver·基础篇#02】服务器的核心---I/O处理单元和任务类

#include <iostream>
#include <fcntl.h>
#include <unistd.h>
#include <sys/epoll.h>

void handleEvent(int fd, uint32_t events)
{
    // 处理事件
    if (events & EPOLLIN)
    {
        char buffer[1024];
        ssize_t bytesRead = read(fd, buffer, sizeof(buffer));
        std::cout << "Read " << bytesRead << " bytes from file" << std::endl;
    }
}

int main()
{
    int fd = open("myfile.txt", O_RDONLY | O_NONBLOCK);

    if (fd < 0)
    {
        std::cerr << "Failed to open file" << std::endl;
        return 1;
    }

    // 创建 epoll 句柄
    int epollFd = epoll_create(1);
    if (epollFd < 0)
    {
        std::cerr << "Failed to create epoll" << std::endl;
        return 1;
    }

    struct epoll_event event = {0};
    event.events = EPOLLIN | EPOLLET; // 监听可读事件，并设置边缘触发模式
    event.data.fd = fd;

    // 添加文件描述符到 epoll 句柄中
    if (epoll_ctl(epollFd, EPOLL_CTL_ADD, fd, &event) < 0)
    {
        std::cerr << "Failed to add fd to epoll" << std::endl;
        close(fd);
        return 1;
    }

    // 调用 epoll_wait 函数等待事件
    while (true)
    {
        struct epoll_event events[1];
        int numEvents = epoll_wait(epollFd, events, sizeof(events) / sizeof(struct epoll_event), -1);
        if (numEvents < 0)
        {
            std::cerr << "Failed to wait for events" << std::endl;
            break;
        }

        for (int i = 0; i < numEvents; ++i)
        {
            handleEvent(events[i].data.fd, events[i].events);
        }
    }

    close(epollFd);
    close(fd);

    return 0;
}

root@ubuntu:/home/ag/webserver1.5# tree
.
├── a.out                   //你应该知道的
├── http_conn.cpp           //存放着用于处理http响应的功能函数
├── http_conn.h				//存放着一堆http_conn.cpp中函数的声明以及一些静态变量和宏定义
├── locker.h				//有三个类互斥锁类locker、条件变量类cond、信号量类sem，库pthread和semaphore的封装
├── main.cpp				//主文件，实现http服务器的核心功能（基于Reactor模式设计）
├── noactive
│   ├── a.out
│   ├── lst_timer.h
│   └── nonactive_conn.cpp
├── resources				//存放静态页面资源，供客户端请求调用
│   ├── images
│   │   └── image1.jpg
│   └── index.html
└── threadpool.h			//线程池，用于处理和响应http请求报文

int main(int argc, char* argv[]){
    //判断参数个数，至少要传递一个端口号
    if(argc <= 1){
        printf("按照如下格式运行: %s port_number\n", basename(argv[0]));
        exit(-1);
    }
	
    //创建线程池，并初始化
    //来一个任务之后，要封装成一个任务对象，交给线程池去处理
    threadpool<http_conn>* pool = NULL;
    try{
        pool = new threadpool<http_conn>; 
    }catch(...){
        exit(-1);
    }  
    
    //创建一个数组用于保存所有的客户端信息
    //每当有新连接进来时，都会在 users 数组中找到一个未使用的 http_conn 对象，进行初始化并保存该连接对应的信息
    http_conn* users  = new http_conn[MAX_FD];
    
}

int main(int argc, char* argv[]){
    //判断参数个数，至少要传递一个端口号
    if(argc <= 1){
        printf("按照如下格式运行: %s port_number\n", basename(argv[0]));
        exit(-1);
    }

    //获取端口号，转换成整数
    int port = atoi(argv[1]);
    
    //使用socketAPI编写Reactor组件，通过监听socket文件描述符获取连接请求
    int listenfd = socket(PF_INET, SOCK_STREAM, 0);//创建用于监听的socket文件描述符
    int reuse = 1;//设置端口复用
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));//让多个进程绑定同一个端口，从而实现负载均衡或者高可用等功能
    
    //存放服务器的地址信息
    struct sockaddr_in address;
    address.sin_family = AF_INET;//使用IPv4协议
    address.sin_addr.s_addr = INADDR_ANY;//监听所有网卡的连接请求
    address.sin_port = htons(port);//将端口号（大端小端）转换为网络字节序,并保存到address结构体中
    bind(listenfd, (struct sockaddr*)&address, sizeof(address));//绑定服务器的地址信息
    
    listen(listenfd, 5);
    
    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);//创建epoll对象，通过该文件描述符对 epoll 进行控制和管理（监听）
    
    //将监听的文件描述符添加到epoll对象中
    addfd(epollfd, listenfd, false);
    http_conn::m_epollfd = epollfd;//赋值
 
}

//添加文件描述符到epoll中
extern void addfd(int epollfd, int fd, bool one_shot);

int main(int argc, char* argv[]){
    //判断参数个数，至少要传递一个端口号
    if(argc <= 1){
        printf("按照如下格式运行: %s port_number\n", basename(argv[0]));
        exit(-1);
    }

    //获取端口号，转换成整数
    int port = atoi(argv[1]);
    
    //使用socketAPI编写Reactor组件，通过监听socket文件描述符获取连接请求
    int listenfd = socket(PF_INET, SOCK_STREAM, 0);//创建用于监听的socket文件描述符
    int reuse = 1;//设置端口复用
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));//让多个进程绑定同一个端口，从而实现负载均衡或者高可用等功能
    
    //存放服务器的地址信息
    struct sockaddr_in address;
    address.sin_family = AF_INET;//使用IPv4协议
    address.sin_addr.s_addr = INADDR_ANY;//监听所有网卡的连接请求
    address.sin_port = htons(port);//将端口号（大端小端）转换为网络字节序,并保存到address结构体中
    bind(listenfd, (struct sockaddr*)&address, sizeof(address));//绑定服务器的地址信息
    
    listen(listenfd, 5);
    
    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_create(5);//创建epoll对象，通过该文件描述符对 epoll 进行控制和管理（监听）
    
    //将监听的文件描述符添加到epoll对象中
    addfd(epollfd, listenfd, false);
    http_conn::m_epollfd = epollfd;//赋值
 
}

//添加文件描述符到epoll中
extern void addfd(int epollfd, int fd, bool one_shot);

int main(int argc, char* argv[]){
    //判断参数个数，至少要传递一个端口号
    ...
    //获取端口号，转换成整数
    ...  
    //使用socketAPI编写Reactor组件，通过监听socket文件描述符获取连接请求
    ...
    //存放服务器的地址信息
    ...     
    //将监听的文件描述符添加到epoll对象中
    ...
    //Reactor组件
    while(true){
        /*
        1、阻塞等待文件描述符监听到的事件
        2、遍历事件数组，判断事件类型，进行对应处理
        */
    }
 
}

//添加文件描述符到epoll中
extern void addfd(int epollfd, int fd, bool one_shot);

int main(int argc, char* argv[]){
    //判断参数个数，至少要传递一个端口号
    ...
    //获取端口号，转换成整数
    ...  
    //使用socketAPI编写Reactor组件，通过监听socket文件描述符获取连接请求
    ...
    //存放服务器的地址信息
    ...     
    //将监听的文件描述符添加到epoll对象中
    ...
    //Reactor组件
    while(true){//死循环不断检测有无事件发生
        //具体来说就是使用epoll_wait获取监听socket的文件描述符所返回的事件数量
        int num = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if(num < 0 && errno != EINTR){
            printf("epoll failure\n");
            break;
        }
        //循环遍历事件数组
        for(int i = 0; i < num; i++){
            int sockfd = events[i].data.fd;
            if(sockfd == listenfd){
                //有客户端连接进来
                struct sockaddr_in client_address;
                socklen_t client_addrlen = sizeof(client_address);

                int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlen);

                if(http_conn::m_user_count >= MAX_FD){
                    //目前连接满了
                    printf("服务器正忙...\n");
                    close(connfd);
                    continue;
                }
                //将新的客户的数据初始化，放到数组中
                users[connfd].init(connfd, client_address);
            }else if(events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR)){
                //对方异常断开或错误异常
                users[sockfd].close_conn();
            }else if(events[i].events & EPOLLIN){
                //判断是否有读事件发生
                if(users[sockfd].read()){//一次性读出数据, read()
                    //成功读完后要交给工作线程处理
                    //调用线程池，追加任务
                    //线程池执行run函数，不断从队列去取
                    //取到就做业务处理，解析、生成响应数据
                    pool->append(users + sockfd);
                }else{//读失败，关闭
                    users[sockfd].close_conn();
                }
            }else if(events[i].events & EPOLLOUT){
                if(!users[sockfd].write()){
                    users[sockfd].close_conn();
                }
            }
        }
    }
}

if(sockfd == listenfd){
    //有客户端连接进来
    struct sockaddr_in client_address;
    socklen_t client_addrlen = sizeof(client_address);

    int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlen);

    if(http_conn::m_user_count >= MAX_FD){
        //目前连接满了
        printf("服务器正忙...\n");
        close(connfd);
        continue;
    }
    //将新的客户的数据初始化，放到数组中
    users[connfd].init(connfd, client_address);
}

else if(events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR)){
    //对方异常断开或错误异常
    users[sockfd].close_conn();
}

else if(events[i].events & EPOLLIN){
    //判断是否有读事件发生
    if(users[sockfd].read()){//一次性读出数据, read()
        //成功读完后要交给工作线程处理
        //调用线程池，追加任务
        //线程池执行run函数，不断从队列去取
        //取到就做业务处理，解析、生成响应数据
        pool->append(users + sockfd);
    }else{//读失败，关闭
        users[sockfd].close_conn();
    }
}

else if(events[i].events & EPOLLOUT){
    if(!users[sockfd].write()){
        users[sockfd].close_conn();
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include "locker.h"
#include "threadpool.h"
#include <signal.h>
#include "http_conn.h"

#define MAX_FD 65535 //最大的文件描述符个数
#define MAX_EVENT_NUMBER 10000 //一次监听的最大事件数

//添加信号捕捉
void addsig(int sig, void(handler)(int)){//信号处理函数
    struct sigaction sa;//创建信号量
    memset(&sa, '\0', sizeof(sa));
    sa.sa_handler = handler;
    sigfillset(&sa.sa_mask);//设置信号临时阻塞等级
    sigaction(sig, &sa, NULL);//注册信号
}

//模拟proactor模式，主线程监听事件
//当有读事件产生，在主线程中一次性读出来，封装成一个任务对象（用任务类）
//然后交给子线程（线程池队列中的工作线程），线程池再去取任务做任务

//添加文件描述符到epoll中
extern void addfd(int epollfd, int fd, bool one_shot);
//从epoll删除文件描述符
extern void removefd(int epollfd, int fd);

//修改文件描述符
extern void modfd(int epollfd, int fd, int ev);


int main(int argc, char* argv[]){
    
    //判断参数个数，至少要传递一个端口号
    if(argc <= 1){
        printf("按照如下格式运行: %s port_number\n", basename(argv[0]));
        exit(-1);
    }

    //获取端口号，转换成整数
    int port = atoi(argv[1]);

    //对SIGPIPE信号进行处理
    addsig(SIGPIPE, SIG_IGN);

    //创建线程池，并初始化
    //任务类：http_conn
    //来一个任务之后，要封装成一个任务对象，交给线程池去处理
    threadpool<http_conn>* pool = NULL;
    try{
        pool = new threadpool<http_conn>; 
    }catch(...){
        exit(-1);
    }

    //创建一个数组用于保存所有的客户端信息
    //users 数组是一个存储 http_conn 对象的数组，每个 http_conn 对象代表一个客户端连接。
    http_conn* users  = new http_conn[MAX_FD];
    
    //写网路通信的代码
    //创建监听的套接字
    int listenfd = socket(PF_INET, SOCK_STREAM, 0);
    //tcp服务端代码
    //设置端口复用（一定要在绑定之前设置）
    int reuse = 1;
    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
    
    //绑定
    //绑定的作用是将服务器的端口号和 IP 地址与一个套接字绑定，
    //使得客户端可以通过相应的 IP 地址和端口号访问到服务器。
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(port);//大端小端转换为网络字节序
    bind(listenfd, (struct sockaddr*)&address, sizeof(address));

    //监听
    //将listenfd这个socket的状态设置为监听状态，等待客户端的连接请求。
    listen(listenfd, 5);
    //listenfd会触发一个可读事件，从而被加入到epoll对象中，并由events数组保存。

    // 创建epoll对象，事件数组，添加监听的文件描述符
    // events 数组的作用是存储 epoll_wait() 函数返回的事件
    epoll_event events[MAX_EVENT_NUMBER];
    // 用于事件管理的epoll对象的文件描述符
    int epollfd = epoll_create(5);//创建epoll对象

    //将监听的文件描述符添加到epoll对象中
    addfd(epollfd, listenfd, false);
    http_conn::m_epollfd = epollfd;//赋值
    
    while(true){//主线程不断循环检测有无事件发生
        /*epoll_wait()会等待事件的发生，一旦事件发生，
        会将该事件的相关信息存储到events数组中，
        主线程会遍历该数组并处理所有发生的事件。*/
        //num代表检测到几个事件
        //调用 epoll_wait() 函数时，我们需要将一个用于存储事件的数组传递给该函数，
        //函数会将检测到的事件存储到该数组中。
        //遍历该数组可以获取到每个事件对应的文件描述符以及该事件所对应的事件类型，根据不同的事件类型，我们可以采取不同的处理方式。
        int num = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
        if(num < 0 && errno != EINTR){
            printf("epoll failure\n");
            break;
        }

        //循环遍历事件数组
        //注意，此时num>0，意味着事件数组events中肯定有元素在，即检测到有事件发生
        for(int i = 0; i < num; i++){
            //从事件数组中取出epoll_wait()检测到的事件，即客户端的连接请求
            /*当events中存储的事件为sockfd可读事件时，表示该socket有数据可读，
            此时应该将读事件交由工作线程去处理。
            当events中存储的事件为sockfd可写事件时，表示该socket可以写入数据，
            此时应该将写事件交由工作线程去处理*/
            int sockfd = events[i].data.fd;//sockfd只是一个名称，表示由epoll_wait()等待并检测到的事件
            /*在服务器中，通常会使用一个监听socket（listenfd）来接受客户端的连接请求，
            当有新的客户端连接到来时，服务器会使用accept函数创建一个新的连接socket（connfd），
            这个新的socket会与客户端的socket建立起通信连接。*/
            if(sockfd == listenfd){
                //有新的客户端连接进来
                struct sockaddr_in client_address;
                socklen_t client_addrlen = sizeof(client_address);

                int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlen);

                if(http_conn::m_user_count >= MAX_FD){
                    //目前连接满了
                    printf("服务器正忙...\n");
                    close(connfd);
                    continue;
                }
                //将新的客户的数据初始化，放到数组中
                /*每当有一个新的客户端连接请求到来时，
                服务器会创建一个新的 http_conn 对象，并将该对象添加到 users 数组中，
                以管理这个客户端连接。*/
                users[connfd].init(connfd, client_address);
            }else if(events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR)){
                //对方异常断开或错误异常
                users[sockfd].close_conn();
            }else if(events[i].events & EPOLLIN){
                //判断是否有读事件发生
                if(users[sockfd].read()){//一次性读出数据, read()
                    //成功读完后要交给工作线程处理
                    //调用线程池，追加任务
                    //线程池执行run函数，不断从队列去取
                    //取到就做业务处理，解析、生成响应数据
                    pool->append(users + sockfd);//将 users + sockfd 所指向的 http_conn 对象追加到线程池的任务队列中。
                    /*users 数组中的每个元素都代表一个客户端连接，
                    数组的下标是该客户端的文件描述符 fd。
                    users + sockfd 就是获取到该客户端连接的 http_conn 对象的指针。
                    然后将该指针作为参数，调用线程池对象的 append 函数，
                    将该指针所指向的 http_conn 对象添加到线程池的任务队列中，
                    等待线程池的工作线程来处理。*/
                }else{//读失败，关闭
                    users[sockfd].close_conn();
                }
            }else if(events[i].events & EPOLLOUT){
                if(!users[sockfd].write()){
                    users[sockfd].close_conn();
                }
            }
        }
    }
    close(epollfd);
    close(listenfd);
    delete[] users;
    delete pool;

    return 0;
}

// 初始化连接,外部调用初始化套接字地址
void http_conn::init(int sockfd, const sockaddr_in& addr){
    m_sockfd = sockfd;
    m_address = addr;
    
    // 端口复用
    int reuse = 1;
    setsockopt(m_sockfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
    addfd(m_epollfd, sockfd, true);//添加到epoll对象中
    m_user_count++;//http_conn对象初始化后，总用户数加1
    init();//为什么要分开？因为下面的init中的信息后面还要单独初始化使用
}

void http_conn::init(){
    bytes_to_send = 0;
    bytes_have_send = 0;

    m_check_state = CHECK_STATE_REQUESTLINE;    // 初始状态为检查请求行
    m_linger = false;       // 默认不保持链接  Connection : keep-alive保持连接

    m_method = GET;         // 默认请求方式为GET
    m_url = 0;              
    m_version = 0;
    m_content_length = 0;
    m_host = 0;
    m_start_line = 0;
    m_checked_idx = 0;
    m_read_idx = 0;
    m_write_idx = 0;

    bzero(m_read_buf, READ_BUFFER_SIZE);//把m_read_buf全置为0
    bzero(m_write_buf, READ_BUFFER_SIZE);
    bzero(m_real_file, FILENAME_LEN);
}

if(sockfd == listenfd){
    //有新的客户端连接进来
}

//有新的客户端连接进来
struct sockaddr_in client_address;
socklen_t client_addrlen = sizeof(client_address);

int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlen);

users[connfd].init(connfd, client_address);

else if(events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR)){
    //对方异常断开或错误异常
    users[sockfd].close_conn();
}

else if(events[i].events & EPOLLIN){
    //判断是否有读事件发生
    if(users[sockfd].read()){//一次性读出数据, read()
        //成功读完后要交给工作线程处理
        //调用线程池，追加任务
        //线程池执行run函数，不断从队列去取
        //取到就做业务处理，解析、生成响应数据
        pool->append(users + sockfd);//将 users + sockfd 所指向的 http_conn 对象追加到线程池的任务队列中。
        /*users 数组中的每个元素都代表一个客户端连接，
                    数组的下标是该客户端的文件描述符 fd。
                    users + sockfd 就是获取到该客户端连接的 http_conn 对象的指针。
                    然后将该指针作为参数，调用线程池对象的 append 函数，
                    将该指针所指向的 http_conn 对象添加到线程池的任务队列中，
                    等待线程池的工作线程来处理。*/
    }else{//读失败，关闭
        users[sockfd].close_conn();
    }
}

// 循环读取客户数据，直到无数据可读或者对方关闭连接
bool http_conn::read(){
    // printf("一次性读完数据\n");
    if(m_read_idx >= READ_BUFFER_SIZE){
        return false;
    }
    int bytes_read = 0;//读取到的字节
    while(true){//开始保存数据
        // 数组起始位置(0)+已经读的数据位置(100)=下次开始写的位置(101)
        // 从m_read_buf+ m_read_idx索引出开始保存数据，大小是READ_BUFFER_SIZE - m_read_idx
        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){
                // 没有数据
                break;
            }
            return false;   
        } else if(bytes_read == 0){   // 对方关闭连接
            return false;
        }
        m_read_idx += bytes_read;//读到数据，更新索引
    }
    // printf("读到了数据：%s\n", m_read_buf);
    return true;
}

pool->append(users + sockfd);

// 由线程池中的工作线程调用，这是处理HTTP请求的入口函数
void http_conn::process(){
    // 解析HTTP请求
    HTTP_CODE read_ret = process_read();
    if(read_ret == NO_REQUEST){
        modfd(m_epollfd, m_sockfd, EPOLLIN);
        return;
    }
    
    // 生成响应
    bool write_ret = process_write(read_ret);
    if(!write_ret){
        close_conn();
    }
    modfd(m_epollfd, m_sockfd, EPOLLOUT);
}

enum HTTP_CODE { NO_REQUEST, GET_REQUEST, BAD_REQUEST, NO_RESOURCE, FORBIDDEN_REQUEST, FILE_REQUEST, INTERNAL_ERROR, CLOSED_CONNECTION };

http_conn::HTTP_CODE http_conn::process_read(){
    //定义初始状态
    LINE_STATUS line_status = LINE_OK;
    HTTP_CODE ret = NO_REQUEST;
    char* text = 0;
    //解析一行数据，得到不同状态
    //OK表示正常
    //主状态机 && 从状态机 || 解析到一行完整数据（或者请求体）
    //这里的主状态机指的是process_read()函数，从状态机指的是parse_line()
    while (((m_check_state == CHECK_STATE_CONTENT) && (line_status == LINE_OK))
                || ((line_status = parse_line()) == LINE_OK)){
        // 获取一行数据
        text = get_line();
        m_start_line = m_checked_idx;
        printf("获取到一行http数据: %s\n", text);

        switch (m_check_state){
            case CHECK_STATE_REQUESTLINE: {
                //解析请求行，也就是GET中的GET
                /*通过请求行的解析我们可以判断该HTTP请求的类型（GET/POST），
                而请求行中最重要的部分就是URL部分，
                我们会将这部分保存下来用于后面的生成HTTP响应*/
                ret = parse_request_line(text);
                if(ret == BAD_REQUEST){
                    return BAD_REQUEST;
                }
                break;//正常解析就break
            }
            case CHECK_STATE_HEADER: {
                ret = parse_headers(text);//解析请求头，GET和POST中空行以上，请求行以下的部分
                if(ret == BAD_REQUEST){
                    return BAD_REQUEST;
                } else if(ret == GET_REQUEST){//遇到换行符就默认你解析完请求头，不管后面还有没有内容
                    return do_request();//解析具体的请求信息
                }
                break;
            }
            case CHECK_STATE_CONTENT: {
                /*解析请求数据，对于GET来说这部分是空的，
                因为这部分内容已经以明文的方式包含在了请求行中的URL部分了；
                只有POST的这部分是有数据的*/
                ret = parse_content(text);
                if(ret == GET_REQUEST){
                    /*do_request()需要做：
                    需要首先对GET请求和不同POST请求
                    （登录，注册，请求图片，视频等等）做不同的预处理，
                    然后分析目标文件的属性，若目标文件存在、对所有用户可读且不是目录时，
                    则使用mmap将其映射到内存地址m_file_address处，并告诉调用者获取文件成功。*/
                    return do_request();
                }
                line_status = LINE_OPEN;
                break;
            }
            default: {
                return INTERNAL_ERROR;
            }
        }
    }
    return NO_REQUEST;//主状态机请求不完整
}

// 写HTTP响应
bool http_conn::write(){
    int temp = 0;
    if(bytes_to_send == 0){
        // 将要发送的字节为0，这一次响应结束。
        modfd(m_epollfd, m_sockfd, EPOLLIN); 
        init();
        return true;
    }
    while(1){
        // 分散写
        temp = writev(m_sockfd, m_iv, m_iv_count);
        if(temp <= -1){
            // 如果TCP写缓冲没有空间，则等待下一轮EPOLLOUT事件，虽然在此期间，
            // 服务器无法立即接收到同一客户的下一个请求，但可以保证连接的完整性。
            if(errno == EAGAIN){
                modfd(m_epollfd, m_sockfd, EPOLLOUT);
                return true;
            }
            unmap();
            return false;
        }
        bytes_have_send += temp;//已发送的字节数
        bytes_to_send -= temp;//剩余需要发送的字节数

        if(bytes_have_send >= m_iv[0].iov_len){
            m_iv[0].iov_len = 0;
            m_iv[1].iov_base = m_file_address + (bytes_have_send - m_write_idx);
            m_iv[1].iov_len = bytes_to_send;
        }
        else{
            m_iv[0].iov_base = m_write_buf+ bytes_have_send;
            m_iv[0].iov_len = m_iv[0].iov_len - temp;
        }
        if(bytes_to_send <= 0){
            // 没有数据要发送了
            unmap();
            modfd(m_epollfd, m_sockfd, EPOLLIN);

            if(m_linger){
                init();
                return true;
            }
            else{
                return false;
            }
        }
    }    
}