一个epoll事件实现的高并发服务/客户端(C语言实现，服务端存储基于hashtable）

　　代码路径：https://github.com/prophetss/epoll-event

　　之前实现了一个简单高效的hashtable（点这里），这里结合epoll基于reactor模型实现了一个高并发服务器。大体思想是将epoll接到的每一个服务请求存储到hashtable里来管理，每一个请求都可以设置独立的回调函数。具体可以先看代码，注释已经写得很详细。代码实现了一个简单server端实例，client端我写了两个例子，一个为Linux C实现，一个是Python实现（主要为了可以在不同系统跑）。C client是fork了产生1024个进程来模仿高并发请求，在同一台机子上测试结果平均每秒读响应34万多次，参考结果如下：

Python client是创建1000个线程来分别不断发送数据，在局域网内两台机子上测试平均结果为每秒31000次左右。比上面慢的多，分析主要原因应该是网络IO瓶颈造成的，参考结果如下：

最后将client代码贴到下面充下长度..

client(C)：

#include <unistd.h>
#include <sys/mman.h>
#include <netinet/in.h>
#include <semaphore.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <wait.h>
#include <string.h>
#include <netdb.h>
#include <stdlib.h>
#include "error.h"


/*进程共享文件用于统计创建进程个数*/
#define PFILE_NAME    "count"

/*需要创建的进程数*/
#define PROCESS_NUM        100

/*每个进程请求次数*/
#define REQUEST_TIMES    10000


struct shared {
    sem_t mutex;    /*信号量用于加锁*/
    int count;        /*进程个数*/
} shared;


void request(const char *server_ip, int server_port)
{
    struct sockaddr_in client_addr;
    bzero(&client_addr, sizeof(client_addr));
    client_addr.sin_family = AF_INET;
    client_addr.sin_addr.s_addr = INADDR_ANY;
    client_addr.sin_port = htons(0);
    
    int client_socket = socket(AF_INET, SOCK_STREAM, 0);
    if(client_socket < 0) exit_throw("create client socket fail");
    
    struct sockaddr_in server_addr;
    bzero((char *)&server_addr, sizeof(server_addr));

    server_addr.sin_family = AF_INET;

    struct hostent *server = gethostbyname(server_ip);
    if(!server) exit_throw("fail to get host name");

    bcopy((char *)server->h_addr, (char *)&server_addr.sin_addr.s_addr, server->h_length);

    server_addr.sin_port = htons(server_port);
    socklen_t server_addr_len = sizeof(server_addr);

    if(connect(client_socket, (struct sockaddr*) &server_addr, server_addr_len) == -1 ) {
        exit_throw("connent to server fail");
    }

    int pid = getpid();

    char content[64] = {0};
    sprintf(content, "%s, pid:%d
", "i am client！", pid);
    for (int i = 0; i < REQUEST_TIMES; ++i) {
        send(client_socket, content, strlen(content), 0);
        usleep(10000);    //10ms
    }

    close(client_socket);

    exit(0);
}

/*
 * 参数1为serverip，参数2为server端口号
 */
int main(int argc,char *argv[])
{
    if(argc != 3) exit_throw("parameter error!
");

    char *server_ip = argv[1];
    int server_port = atoi(argv[2]);

    struct shared *psh;

    /*创建共享文件*/
    int fd = open(PFILE_NAME, O_RDWR | O_CREAT | O_TRUNC, 0666);
    /*初始化0*/
    int ret_len = write(fd, &shared, sizeof(struct shared));
    if (ret_len != sizeof(struct shared)) {
        exit_throw("write error!
");
    }
    /*映射内存*/
    psh = mmap(NULL, sizeof(struct shared), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    close(fd);

    sem_init(&psh->mutex, 1, 1);
    
    int i, pid[PROCESS_NUM];
    for (i = 0; i < PROCESS_NUM; i++) {
        pid_t fpid = fork();
        if (0 == fpid) {
            pid[i]=getpid();
            sem_wait(&psh->mutex);
            psh->count++;
            printf("%d processes was created!
", psh->count);
            sem_post(&psh->mutex);
            request(server_ip, server_port);
        }
        else if (fpid > 0) {
        }
        else {
            exit_throw("fork error!");
        }
    }

    /*等待所有子进程创建完毕*/
    while (psh->count < PROCESS_NUM) {
        sleep(0);
    }

    wait(NULL);

    remove(PFILE_NAME);
    
    printf("exit all!
");

    return 0;
}

client(Python )：

# -*- coding: UTF-8 -*-

import threading
import random
import socket
import time
import sys

class tThread (threading.Thread):
    counter = 0
    def __init__(self, threadID, name, ip, port):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.ip = ip
        self.port = port
    def run(self):
        print("开始线程：", self.name+str(self.threadID))
        sendData(self.name, self.threadID, self.counter, self.ip, self.port)
        print("退出线程：", self.name+str(self.threadID))

def sendData(name, threadID, counter, ip, port):
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((ip, port))
    for i in range(1000000):
        counter = counter + 1
        current_time = time.asctime()
        try:
            s.send(("%d times: i am %s and now is %s.
"%(counter, str(name)+str(threadID), str(current_time))).encode('utf-8'))
        except Exception as e:
            pass
    s.close()

'''
    参数1：server端ip
    参数2：server端口号
'''
if __name__ == '__main__':
    threads = []
    for i in range(1000):
        t = tThread(i, "Thread", sys.argv[1], int(sys.argv[2]))
        t.start()
        threads.append(t)
    for x in threads:
        x.join()

 2018-07-08 19:29:25更新：添加测试