小型WebServer项目

typedef void (*CB)(void*);          //线程回调函数, 线程任务
struct task { 
    void* data;               //存储数据
    int fd;                 //对应sockfd
    struct reactor* reactor;        //任务所属反应堆
    CB cb;                  //回调任务. task_cb
    struct task* next;            
};
struct taskqueue {
    struct task* front;
    struct task* tail;            
    pthread_mutex_t lock;         //锁, 阻塞队列 
    pthread_cond_t cond;          //条件变量, 通知消费. 任务到来
    int is_running;             //控制线程池的开启或关闭
};

extern struct taskqueue* init_taskqueue();            //创建任务队列
extern void push_task(struct taskqueue* tq, struct task* ptask);//push任务
extern struct task* pop_task(struct taskqueue* tq);       //pop任务
extern void* thread_routine(void* arg);             //线程函数
extern void start_threadspool(struct taskqueue* taskq, int n);  //开启线程池
extern void clear_threadspool(struct taskqueue* taskq);     //销毁线程池 

epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, event);
//向操作系统内核中添加一个结点. 向内核注册监视的event事件
epfd: epoll句柄
EPOLL_CTL_ADD: 添加事件
EPOLL_CTL_MOD: 修改事件
EPOLL_CTL_DEL: 删除事件
sockfd: 描述符
event:  事件结构体指针, struct epoll_event*

nready = epoll_wait(epfd, events, MAX_EVENTS, -1);
//阻塞等待收集到来活跃的IO事件
nready: 就绪事件数目
events: event数组, 存储事件
MAX_EVENTS: 数组容量
-1:     一直阻塞等待. timeout: 阻塞返回事件, 定时触发. 超时处理

//循环分发到来的活跃IO事件
for (; i < nready; ++i) {
        struct epoll_event ev = evs[i];//拿出事件
        int mask = 0;
        if (ev.events & EPOLLIN) mask |= EPOLLIN;
        if (ev.events & EPOLLOUT) mask |= EPOLLOUT;
        if (ev.events & EPOLLHUP) mask |= EPOLLIN|EPOLLOUT; 
        //将事件触发调用
        if (ev.events & EPOLLIN) {
            struct event_item* item = ev.data.ptr;
            item->callback(item->fd, mask, item->arg);
        }
        if (ev.events & EPOLLOUT) {
            struct event_item* item = ev.data.ptr;
            item->callback(item->fd, mask, item->arg);
        }
    }

1.  LT: level tiggered，水平触发。不停的触发, 只要socket缓冲区中存在数据就会不停的触发epoll_wait的返回. 问题所在：对于监控sockfd缓冲区中的数据不进行处理. 就会一直不停的触发epoll_wait的返回. 效率低
2.  ET: edage tiggered, 边沿触发, 边沿，也就是说只触发一次。触发且仅触发一次. 不论一次之后缓冲区中还有没有剩余数据，都将不再进行触发. 数据从无到有的时候触发那一次. 用户态缓存必须开的足够大, 如果一次无法完成所有数据的读取. 将不会再触发epoll_wait. 等到下一次IO活跃才会再触发epoll_wait收集活跃IO事件
3.  但是如果我们能保证一次性绝对将所有数据处理完, LT其实和ET效率也是一样的，并不会造成说LT更多的epoll_wait调用效率低下的问题

//日志等级， 级别
enum Level {
    DEBUG=0,//debug信息
    INFO,//普通信息
    WARN,//警告
    ERROR,//错误信息
    FATAL,//致命错误
    LEVEL_COUNT//日志级别数目
};
struct Logger {
    FILE* _fp;//日志文件
};
extern const char* _level[LEVEL_COUNT];//存储日志级别
static struct Logger* g_logger;
//初始化日志系统, 仅仅初始化一次
int init_logger();    //初始化日志系统
void destroy_logger();//销毁日志系统
//登记各种级别的日志函数， 其实都是调用了log
void log_debug(const char *file, int line, const char* fmt, ...);
void log_info(const char *file, int line, const char* fmt, ...);
void log_warn(const char *file, int line, const char* fmt, ...);
void log_error(const char *file, int line, const char* fmt, ...);
void log_fatal(const char *file, int line, const char* fmt, ...);
//登记日志
void log(int level, const char *file, int line, const char* fmt, va_list ap);

//登记日志. 核心
void log(int level, const char *file, int line, const char* fmt, va_list ap) {
    //先获取本地时间
    time_t t = time(NULL);
    struct tm* ptm = localtime(&t);
    char buff[32] = "0";
    //strftime
    strftime(buff, sizeof(buff), "%Y-%m-%d %H:%M:%S ", ptm);
    flockfile(g_logger->_fp);
    fprintf(g_logger->_fp, buff);//log time
    fprintf(g_logger->_fp, "%s ", _level[level]);//log level
    fprintf(g_logger->_fp, "%s:%d ", file, line);
    vfprintf(g_logger->_fp, fmt, ap);
    fprintf(g_logger->_fp, "\r\n");
    fflush(g_logger->_fp);
    funlockfile(g_logger->_fp);
}

#define _DEBUG
#define _INFO
#define _ERROR
#define _WARN
#define _FATAL
#ifdef _DEBUG
#define debug(fmt, args...) \
    log_debug(__FILE__, __LINE__, fmt, ##args)
#else 
#define debug(fmt, args...)
#endif
#ifdef _ERROR
#define error(fmt, args...) \
    log_error(__FILE__, __LINE__, fmt, ##args)
#else 
#define error(fmt, args...)
#endif
#ifdef _WARN
#define warn(fmt, args...) \
    log_warn(__FILE__, __LINE__, fmt, ##args)
#else 
#define warn(fmt, args...)
#endif
#ifdef _INFO
#define info(fmt, args...) \
    log_info(__FILE__, __LINE__, fmt, ##args)
#else 
#define info(fmt, args...)
#endif
#ifdef _FATAL
#define fatal(fmt, args...) \
    log_fatal(__FILE__, __LINE__, fmt, ##args)
#else 
#define fatal(fmt, args...)
#endif