2 程序逻辑

2 程序逻辑

1 main 函数

2 具体流程模块函数

2.1 初始化全局结构体

int manager_init() {
    g_manager.m_pool = ukey_create_pool(2048); // 创建内存池
    g_manager.t_pool = threadpool_create(50, 1024, 1024); // 创建线程池
    g_manager.conn = (connections_t *)ukey_palloc(g_manager.m_pool, sizeof(connections_t ) * 1024);// 预先分配1024个连接
    g_manager.nconnections = 1024;
    conn_init(g_manager.conn, g_manager.nconnections);// 给每个连接初始化(创建内存池，分为读连接，写连接)
    g_manager.ep_fd = epoll_create(EPOLL_SIZE);// 创建epoll描述符
    if (g_manager.ep_fd < 0) {
        perror("epoll create error");
        return -1;
    }
    g_manager.ep_events = (struct epoll_event *)ukey_palloc(g_manager.m_pool, sizeof(struct epoll_event) * 4096); // 预先分配4096个epoll事件的内存空间
    g_manager.nep_events = 4096;
    pthread_mutex_init(&(g_manager.conn_lock), NULL);// 初始化锁

    return 0;
}

2.2 创建监听套接字

    struct sockaddr_in server_addr;
    int listen_fd;
    int ep_fd = g_manager.ep_fd;
    listen_fd = socket(AF_INET,SOCK_STREAM,0);

2.3 初始化连接设置

2.3.1 conn_set(listen_fd, EPOLLIN, (void *)add_conn)

int conn_set(int fd, int events, void (*call_back)(int, int, void *)) {
    if (fd > g_manager.nconnections) {
        fprintf(stderr, "fd max limits\n");
        return -1;
    }

    connections_t *new_conn = &g_manager.conn[fd]; // 找到对应连接预先分配的空间
    if (new_conn == NULL) {
        fprintf(stderr, "conn set error\n");
        return -1;
    }
    event_t *new_ev = (event_t *)ukey_palloc(new_conn->m_cpool, sizeof(event_t)); //在连接的内存空间中分配一个事件的空间
    if (new_ev == NULL) {
        fprintf(stderr, "alloc from coon m_cpoll error\n");
        return -1;
    }
    void *arg = (void *)new_ev;
    event_set(new_ev, fd, call_back, arg); // 设置事件回调函数
    event_add(g_manager.ep_fd, events, new_ev, 1);// 添加事件
                            // 根据传入的参数设置对应得事件类型时读还是写    
    if (events & EPOLLIN) {
        new_conn->read = new_ev; 
    }
    if (events & EPOLLOUT) {
        new_conn->write = new_ev;
    }
    
    return 0;
}   

2.3.2 event_set(new_ev, fd, call_back, arg);

void event_set(event_t *ev, int fd, void (*call_back)(int, int, void *), void *arg) {

    ev->ev_fd = fd; //事件的描述符
    ev->ev_callback = call_back; // 事件的回调函数
    ev->ev_arg = arg; // 参数
    ev->ev_events = 0; // 事件类型 EPOLLIN 还是 EPOLLOUT
    ev->ev_status = 0; // 控制事件的状态  是否已经在 epoll 监听中

    return ;
}

2.3.3 event_add(g_manager.ep_fd, events, new_ev, 1);

void event_add(int ep_fd, int events, event_t *ev, int et_flag) {
    struct epoll_event ep_event = {0, {0}}; // 初始化epoll_event
    int option; // 属性参数

    if (et_flag) {
        fcntl(ev->ev_fd, F_SETFL, O_NONBLOCK); //设置为非阻塞epoll ET触发
        events |= EPOLLET;                     // event 本来为 EPOLLIN 读事件
    }

    ep_event.data.fd = ev->ev_fd; // 设置监听的描述符
    ep_event.events = ev->ev_events = events;  // 设置属性

    if (ev->ev_status == 1) {
        option = EPOLL_CTL_MOD; // 如果之前已经在epoll中 则为修改
    } else {
        option = EPOLL_CTL_ADD; // 之前没在epoll中 添加
        ev->ev_status = 1;
    }

    if (epoll_ctl(ep_fd, option, ev->ev_fd, &ep_event) < 0) { // 在epoll中注册事件
        perror("epoll ctl error");
        exit(-1);
    }
    return ;
}

2.4 监听端口属性设置

    bzero(&server_addr,sizeof(server_addr));
    
    // 设置端口复用
    int flag = 1;
    setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&flag,sizeof(flag));// SOL_SOCKET: 基本套接口  SO_REUSERADDR 允许重用本地地址和端口（在timewait状态时）
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(SERV_PORT);
    
    bind(listen_fd,(struct sockaddr *)&server_addr,sizeof(server_addr));
    listen(listen_fd,20);

2.5 阻塞在 epoll_wait()

int event_count = epoll_wait(ep_fd, g_manager.ep_events, g_manager.nep_events, -1);

2.6 处理事件

int i = 0;
for(; i < event_count; i++)
{
    int fd = g_manager.ep_events[i].data.fd; // 得到连接的描述符
    int events = g_manager.ep_events[i].events; // 得到连接对应的事件
    connections_t *ev_conn = &g_manager.conn[fd]; // 找到触发事件的实体

    if (ev_conn == NULL)
        continue;
    if (events & EPOLLIN) { // 如果是读事件
        if (ev_conn->read) { // 如果有事件挂在连接上
            event_t *read_ev = ev_conn->read; // 取得对应的事件
            if (read_ev->ev_callback) // 若有回调函数 执行回调函数
                read_ev->ev_callback(read_ev->ev_fd, read_ev->ev_events, read_ev->ev_arg);
        }
    }
    if (events & EPOLLOUT) { // 如果是写事件
        if (ev_conn->write) {
            event_t *write_ev= ev_conn->write;
            write_ev->ev_callback(write_ev->ev_fd, write_ev->ev_events, write_ev->ev_arg);
        }
    }
    /* 需要扩展epoll_event数组 */
    if (event_count == g_manager.nep_events) {
        if (epev_ralloc() < 0) {
            fprintf(stderr, "epoll event realloc error\n");
            exit(-1);
        }
    }
}

转载于:https://www.cnblogs.com/eemjwu/p/10588605.html