epoll與線程池實現的服務器端示例

[代碼] [C/C++]代碼

/* Linux 2.6 x86_64 only*/
#include <pthread.h> 
#include <string.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <stdio.h> 
#include <fcntl.h>
 
#include <arpa/inet.h> 
#include <sys/epoll.h> 
#include <sys/errno.h>
#include <sys/socket.h> 
 
#define THREAD_MAX 20 
#define LISTEN_MAX 20 
#define SERVER_IP "127.0.0.1" 
 
typedef struct {
    char ip4[128]; 
    int port; 
    int fd; 
} LISTEN_INFO; 
 
//服務器參數 
static LISTEN_INFO s_listens[LISTEN_MAX]; 
 
//線程池參數 
static unsigned int s_thread_para[THREAD_MAX][8];//線程參數 
static pthread_t s_tid[THREAD_MAX];//線程ID 
pthread_mutex_t s_mutex[THREAD_MAX];//線程鎖 
 
//私有函數 
static int init_thread_pool(void);//初始化數據
static int init_listen4(char *ip4, int port, int max_link); //初始化監聽
 
//線程函數 
void * test_server4(unsigned int thread_para[]);
 
//設置文件描述符爲NonBlock
bool setNonBlock(int fd)
{
    int flags = fcntl(fd, F_GETFL, 0);
    flags |= O_NONBLOCK;
    if(-1 == fcntl(fd, F_SETFL, flags))
        return false;
    return true;
}
  
int main(int argc, char *argv[])//客戶端驅動 
{ 
    //臨時變量 
    int i, j, rc; 
 
    int sock_listen; //監聽套接字 
    int sock_cli; //客戶端連接 
    int listen_index; 
 
    int epfd; 
    int nfds; 
    struct epoll_event ev; 
    struct epoll_event events[LISTEN_MAX];
      
    socklen_t addrlen; //地址信息長度 
    struct sockaddr_in addr4; //IPv4地址結構 
 
    //線程池初始化 
    rc = init_thread_pool(); 
    if (0 != rc) exit(-1); 
 
    //初始化服務監聽 
    for(i = 0; i < LISTEN_MAX; i++) { 
        sprintf(s_listens[i].ip4, "%s", SERVER_IP); 
        s_listens[i].port = 40000 + i; 
        //創建監聽 
        rc = init_listen4(s_listens[i].ip4, s_listens[i].port, 64); 
        if (0 > rc) { 
            fprintf(stderr, "無法創建服務器監聽於%s:%d\r\n", s_listens[i].ip4, s_listens[i].port); 
            exit(-1); 
        } else {
            fprintf(stdout, "已創建服務器監聽於%s:%d\r\n", s_listens[i].ip4, s_listens[i].port);  
        } 
        s_listens[i].fd = rc; 
    } 
      
    //設置集合 
    epfd = epoll_create(8192); 
    for (i = 0; i < LISTEN_MAX; i++) { 
        //加入epoll事件集合 
        ev.events = EPOLLIN | EPOLLET;
        ev.data.u32 = i;//記錄listen數組下標 
        if (epoll_ctl(epfd, EPOLL_CTL_ADD, s_listens[i].fd, &ev) < 0) { 
            fprintf(stderr, "向epoll集合添加套接字失敗(fd =%d)\r\n", rc); 
            exit(-1); 
        } 
    } 
      
    //服務循環 
    for( ; ; ) { 
        //等待epoll事件 
        nfds = epoll_wait(epfd, events, LISTEN_MAX, -1); 
        //處理epoll事件 
        for(i = 0; i < nfds; i++) { 
            //接收客戶端連接 
            listen_index = events[i].data.u32; 
            sock_listen = s_listens[listen_index].fd; 
            addrlen = sizeof(struct sockaddr_in); 
            bzero(&addr4, addrlen); 
              
            sock_cli = accept(sock_listen, (struct sockaddr *)&addr4, &addrlen); 
            if(0 > sock_cli) { 
                fprintf(stderr, "接收客戶端連接失敗\n"); 
                continue; 
            } else {
                char *myIP = inet_ntoa(addr4.sin_addr);
                printf("accept a connection from %s...\n", myIP); 
            } 
              
            setNonBlock(sock_cli);
            //查詢空閒線程對 
            for(j = 0; j < THREAD_MAX; j++) { 
                if (0 == s_thread_para[j][0]) break; 
            } 
            if (j >= THREAD_MAX) { 
                fprintf(stderr, "線程池已滿, 連接將被放棄\r\n"); 
                shutdown(sock_cli, SHUT_RDWR); 
                close(sock_cli); 
                continue; 
            } 
            //複製有關參數 
            s_thread_para[j][0] = 1;//設置活動標誌爲"活動" 
            s_thread_para[j][1] = sock_cli;//客戶端連接 
            s_thread_para[j][2] = listen_index;//服務索引 
            //線程解鎖 
            pthread_mutex_unlock(s_mutex + j); 
        }//end of for(i;;) 
    }//end of for(;;) 
 
    exit(0); 
} 
 
static int init_thread_pool(void) 
{ 
    int i, rc; 
 
    //初始化線程池參數 
    for(i = 0; i < THREAD_MAX; i++) { 
        s_thread_para[i][0] = 0;//設置線程佔用標誌爲"空閒" 
        s_thread_para[i][7] = i;//線程池索引 
        pthread_mutex_lock(s_mutex + i);// 這個地方爲什麼要加鎖？不加鎖創建監聽有時會不成功 
    } 
 
    //創建線程池 
    for(i = 0; i < THREAD_MAX; i++) { 
        rc = pthread_create(s_tid + i, 0, (void* (*)(void *))test_server4, (void *)(s_thread_para[i])); 
        if (0 != rc) { 
            fprintf(stderr, "線程創建失敗\n"); 
            return(-1); 
        } 
    } 
 
    //成功返回 
    return(0); 
} 
 
static int init_listen4(char *ip4, int port, int max_link) 
{ 
    //臨時變量 
    int sock_listen4; 
    struct sockaddr_in addr4; 
    unsigned int optval; 
    struct linger optval1; 
 
    //初始化數據結構 
    bzero(&addr4, sizeof(addr4)); 
    //inet_pton將點分十進制IP轉換爲整數
    inet_pton(AF_INET, ip4, &(addr4.sin_addr)); 
    addr4.sin_family = AF_INET; 
    //htons將無符號short從主機字節序(x86:Big-Endian)轉換爲網絡字節序
    addr4.sin_port = htons(port); 
      
    //創建流類型的SOCKET 
    sock_listen4 = socket(AF_INET, SOCK_STREAM, 0); 
    if (0 > sock_listen4) {
        fprintf(stderr, "創建socket異常, sock_listen4:%d\n", sock_listen4);
        perror("創建socket異常");
        return(-1); 
    }
      
    //設置SO_REUSEADDR選項(服務器快速重起) 
    optval = 0x1; 
    setsockopt(sock_listen4, SOL_SOCKET, SO_REUSEADDR, &optval, 4); 
 
    //設置SO_LINGER選項(防範CLOSE_WAIT掛住所有套接字) 
    optval1.l_onoff = 1; 
    optval1.l_linger = 60; 
    setsockopt(sock_listen4, SOL_SOCKET, SO_LINGER, &optval1, sizeof(struct linger)); 
 
    if (0 > bind(sock_listen4, (struct sockaddr *)&addr4, sizeof(addr4))) { 
        fprintf(stderr, "bind socket異常, sock_listen4:%d\n", sock_listen4);
        perror("bind socket異常");
        close(sock_listen4);
        return(-1); 
    } 
 
    if (0 > listen(sock_listen4, max_link)) { 
        fprintf(stderr, "listen socket異常, sock_listen4:%d\n", sock_listen4);
        perror("listen socket異常");
        close(sock_listen4); 
        return(-1); 
    } 
 
    return (sock_listen4); 
} 
 
void * test_server4(unsigned int thread_para[]) 
{ 
    //臨時變量 
    int sock_cli; //客戶端連接 
    int pool_index; //線程池索引 
    int listen_index; //監聽索引 
 
    char buff[32768]; //傳輸緩衝區 
    int i, j, len; 
    char *p; 
 
    //線程脫離創建者 
    pthread_detach(pthread_self()); 
    pool_index = thread_para[7]; 
 
wait_unlock: 
    pthread_mutex_lock(s_mutex + pool_index);//等待線程解鎖 
 
    //線程變量內容複製 
    sock_cli = thread_para[1];//客戶端連接 
    listen_index = thread_para[2];//監聽索引 
 
    //接收請求 
    len = recv(sock_cli, buff, sizeof(buff), MSG_NOSIGNAL); 
    printf("%s\n", buff);
      
    //構造響應 
    p = buff; 
    //HTTP頭 
    p += sprintf(p, "HTTP/1.1 200 OK\r\n"); 
    p += sprintf(p, "Content-Type: text/html\r\n"); 
    p += sprintf(p, "Connection: closed\r\n\r\n"); 
    //頁面 
    p += sprintf(p, "<html>\r\n<head>\r\n"); 
    p += sprintf(p, "<meta content=\"text/html; charset=UTF-8\" http-equiv=\"Content-Type\">\r\n"); 
    p += sprintf(p, "</head>\r\n"); 
    p += sprintf(p, "<body style=\"background-color: rgb(229, 229, 229);\">\r\n"); 
 
    p += sprintf(p, "<center>\r\n"); 
    p += sprintf(p, "<H3>連接狀態</H3>\r\n"); 
    p += sprintf(p, "<p>服務器地址 %s:%d</p>\r\n", s_listens[listen_index].ip4, s_listens[listen_index].port); 
    j = 0; 
    for(i = 0; i < THREAD_MAX; i++) { 
        if (0 != s_thread_para[i][0]) j++; 
    } 
    p += sprintf(p, "<H3>線程池狀態</H3>\r\n"); 
    p += sprintf(p, "<p>線程池總數 %d 活動線程總數 %d</p>\r\n", THREAD_MAX, j); 
    p += sprintf(p, "</center></body></html>\r\n"); 
    len = p - buff; 
      
    //發送響應 
    send(sock_cli, buff, len, MSG_NOSIGNAL); 
    memset(buff, 0, 32768);
      
    //釋放連接 
    shutdown(sock_cli, SHUT_RDWR); 
    close(sock_cli); 
 
    //線程任務結束 
    thread_para[0] = 0;//設置線程佔用標誌爲"空閒" 
    goto wait_unlock; 
 
    pthread_exit(NULL); 
}