朴素、Select、Poll和Epoll网络编程模型实现和分析——朴素模型

        做Linux网络开发，一般绕不开标题中几种网络编程模型。网上已有很多写的不错的分析文章，它们的基本论点是差不多的。但是我觉得他们讲的还不够详细，在一些关键论点上缺乏数据支持。所以我决定好好研究这几个模型。（转载请指明出于breaksoftware的csdn博客）

        在研究这些模型前，我决定按如下步骤去做：

1. 实现朴素模型
2. 实现发请求的测试程序
3. 实现Select模型，测试其效率
4. 实现Poll模型，测试其效率
5. 实现Epoll模型，测试其效率
6. 分析各模型性能，分析和对比其源码
7. 针对各模型特点，修改上述程序进行测试和分析

        朴素模型是我们编程时可以使用的最简单的一种模型。因为没有一个确切的名字可以称呼，我索性叫它朴素模型。我选择先实现它，一是为了由易而难，二是为了遵循模型发展的过程、体会技术发展的历程。在实现完朴素模型之后，我们要去实现一个用于发送请求的测试程序，它将帮助我们发送大量的请求，以便于之后我们对各个模型进行可用性测试。之后我们再去实现Select、Poll和Epoll网络模型。这个顺序也是技术发展的顺序，我们可以在实现前一个模型时分析其优缺点，然后在后一个模型分析中，看到其对这些缺点的改进方案，体会技术进步的过程。

        为了便于之后各个模型的对比，我会尽可能的重用代码，即各个模型功能相同的模块将使用相同的函数去实现，如果实在不可以重用，则使用参数进行区分，但是区分的代码片段将足够的小。所以，我们将在本文看到大部分重要的代码实现片段。

        为了比较直观的观察各个模型的执行，我们将在各个模型执行前，启动一个打印统计信息的线程

         err = init_print_thread();         if (err < 0) {                 perror("create print thread error");                 exit(EXIT_FAILURE);         }

        init_print_thread函数将被各个模型使用，wait_print_thread是用于等待该打印结果的线程退出。由于我并不准备让这个线程退出，所以wait_print_thread往往用来阻塞主线程。

 pthread_t g_print_thread;  int init_print_thread() {         return pthread_create(&g_print_thread, NULL, print_count, NULL); }  void wait_print_thread() {         pthread_join(g_print_thread, NULL); }

        print_count函数是用于线程执行的实体，它每隔一秒钟打印一条记录

static int g_request_count = 0;static int g_server_suc = 0;static int g_client_suc = 0;static int g_read_suc = 0;static int g_write_suc = 0;static int g_server_fai = 0;static int g_client_fai = 0;static int g_read_fai = 0;static int g_write_fai = 0;void* print_count(void* arg) {        struct timeval cur_time;        int index = 0;        fprintf(stderr, "index\tseconds_micro_seconds\tac\tst\tsr\tsw\tft\tfr\tfw\n");        while (1) {                sleep(1);                gettimeofday(&cur_time, NULL);                fprintf(stderr, "%d\t%ld\t%d\t%d\t%d\t%d\t%d\t%d\t%d\n",                                index,                                cur_time.tv_sec * 1000000 + cur_time.tv_usec,                                g_request_count,                                g_server_suc > g_client_suc ? g_server_suc : g_client_suc,                                g_read_suc,                                g_write_suc,                                g_server_fai > g_client_fai ? g_server_fai : g_client_fai,                                g_read_fai,                                g_write_fai);                index++;        }}

        上述各数据的定义如下：        

• g_request_count用于记录总请求数；
• g_server_suc是用于记录服务行为成功数，其场景为：读取客户端成功且发送回包成功
• g_server_fai是记录服务其行为失败数，其场景为：1 读取客户端失败；2 读取客户端成功但是发送回包失败；
• g_client_suc用于记录客户端行为成功数，其场景为：发送包成功且读取服务器回包成功；
• g_client_fai用于记录客户端行为失败数，其场景为：1 发送包失败； 2 发送包成功但是接收服务器回包失败；
  
• g_read_suc用于记录读取行为成功数，其场景为： 1 服务器读取客户端请求包成功； 2 客户端读取服务器回包成功；
• g_read_fai用于记录读取行为失败数，其场景为： 1 服务器读取客户端请求包失败； 2 客户端读取服务器回包失败；
  
• g_write_suc用于记录发送行为成功数，其场景为： 1 客户端向服务器发送请求包成功； 2 服务器向客户端回包成功；
  
• g_write_fai用于记录发送行为失败数，其场景为： 1 客户端向服务器发送请求包失败； 2 服务器向客户端回包失败；
  

        通过数据的打印，我们将知道服务器和客户端执行执行的过程，以及出问题的环节，还有服务器的丢包情况。

        下一步，我们需要创建一个供客户端连接的Socket。

listen_sock = make_socket(0);

        我们对make_socket传入了参数0，是因为我们不要求创建的监听Socket具有异步属性。

intmake_socket(int asyn) {int listen_sock = -1;int rc = -1;int on = 1;struct sockaddr_in name;listen_sock = socket(AF_INET, SOCK_STREAM, 0);if (listen_sock < 0) {perror("create socket error");exit(EXIT_FAILURE);}rc = setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof(on));if (rc < 0) {perror("setsockopt error");exit(EXIT_FAILURE);}if (asyn) {rc = ioctl(listen_sock, FIONBIO, (char*)&on);if (rc < 0) {perror("ioctl failed");exit(EXIT_FAILURE);}}name.sin_family = AF_INET;name.sin_port = htons(PORT);name.sin_addr.s_addr = htonl(INADDR_ANY);if (bind(listen_sock, (struct sockaddr*)&name, sizeof(name)) < 0) {perror("bind error");exit(EXIT_FAILURE);}return listen_sock;}

        这个函数中我们使用了socket函数创建了一个TCP的Socket。并使用bind函数将该socket绑定到本机特定的端口上。

        在朴素模型中，我们让服务器是一个同步处理过程。于是不要求之后的连接具有异步属性，所以我们创建该Socket时传了参数0——让监听Socket不具有异步特性。在之后介绍的Select、Poll和Epoll模型中，我们需要客户端接入的连接是异步的，于是我们就传递了参数1，让监听Socket具有异步特性，这样通过它接入的连接也是异步的。

        Socket绑定之后，服务器就要开始监听客户端的接入

if (listen(listen_sock, SOMAXCONN) < 0) {perror("listen error");exit(EXIT_FAILURE);}

        SOMAXCONN是可以同时处理的最大连接数，它是一个系统宏。在我系统上它的值是128。

        最后，我们在一个死循环中接收并处理客户端的请求

while (1) {int new_sock;new_sock = accept(listen_sock, NULL, NULL);if (new_sock < 0) {perror("accept error");exit(EXIT_FAILURE);}

        通过accept我们将获得接入的socket。如果socket值合法，我们则需要让接受的请求数自增1

request_add(1);

        request_add函数将在之后不同模型以及测试程序中被调用，而且会是在不同的线程中调用。于是这儿就引入一个多线程的问题。我并不打算使用锁等方法，而是利用简单的原子操作来实现。

void request_add(int count) {__sync_fetch_and_add(&g_request_count, count);}

        由于我们设计的朴素模式是一个同步过程，所以接入的socket不是异步的。当一些特殊情况发生时，之后的读取socket内容的行为或者往socket中写入内容的行为可能会卡住。这样将导致整个服务都卡住，这是我们不希望看到的。于是我们需要对该同步socket设置操作超时属性。

set_block_filedes_timeout(new_sock);

voidset_block_filedes_timeout(int filedes) { struct timeval tv_out, tv_in;tv_in.tv_sec = READ_TIMEOUT_S;    tv_in.tv_usec = READ_TIMEOUT_US;if (setsockopt(filedes, SOL_SOCKET, SO_RCVTIMEO, &tv_in, sizeof(tv_in)) < 0) {perror("set rcv timeout error");exit(EXIT_FAILURE);}tv_out.tv_sec = WRITE_TIMEOUT_S;    tv_out.tv_usec = WRITE_TIMEOUT_US;if (setsockopt(filedes, SOL_SOCKET, SO_SNDTIMEO, &tv_out, sizeof(tv_out)) < 0) {perror("set rcv timeout error");exit(EXIT_FAILURE);}}

        这儿要说明下，我在网上看过很多人提问说通过上述方法设置超时属性无效。其实是他们犯了一个错误，就是将socket设置为异步属性。如果socket既设置为异步属性，又设置了超时，socket当然是按异步特点去执行的，超时设置也就无效了。

        还有一个问题，就是有些同学在自己设计服务器和客户端时发生了“死锁”问题（非严格定义意义上的死锁）。那是因为设计的服务器和客户端都是同步的，而且socket都没有设置超时。这样在客户端调用完write之后进入read时，服务器此时也是read状态，导致了“死锁”。但是这个问题并不是经常发生，因为大部分同学实现read时给了一个很大的缓存，并认为读取的内容一次性可以读完。而没有考虑到一次read操作可能读不完全部数据的情况，比如下面的实现

while (nbytes > 0) {nbytes = recv(filedes, buffer, sizeof(buffer) - 1, 0);if (nbytes > 0) {total_length_recv += nbytes;}//buffer[nbytes] = 0;//fprintf(stderr, "%s", buffer);}

        这段服务器read操作考虑到了一次性可能读不完全部数据的问题。但是如果客户端发送完数据后，服务器第一次recv可以把全部数据读取出来了。由于读取的数据大于0，于是再次进入读取操作，这个时候，客户端已经处于读取服务器返回的阶段。由于socket是同步的，且未设置超时，导致服务器一直卡在再次读取的操作中，这样就发生了“死锁”。其实这个过程非常有意思，当我们对一段不健壮的代码进行加固时，往往会掉到另外一个坑里。但是只要我们努力的从坑里跳出来，就会豁然开朗且认识到很多别人忽视的问题。

        我们再回到正题，我们设置好socket超时属性后，就开始让服务器读取客户端的输入内容，如果输入内容读取成功，则往客户端回包。最后服务器将该次连接关闭

if (0 == server_read(new_sock)) {server_write(new_sock);}close(new_sock);

        server_read方法在底层调用了read_data方法，read_data方法是我们整个代码的两个关键行为之一

intis_nonblock(int fd) {int flags = fcntl(fd, F_GETFL);if (flags == -1) {perror("get fd flags error");exit(EXIT_FAILURE);}return (flags & O_NONBLOCK) ? 1 : 0;}intread_data(int filedes, int from_server) {char buffer[MAXMSG];int nbytes;int total_len_recv;int wait_count = 0;int rec_suc = 0;total_len_recv = 0;while (1) {nbytes = recv(filedes, buffer, sizeof(buffer) - 1, 0);if (nbytes < 0) {if (is_nonblock(filedes)) {if (EAGAIN == errno || EWOULDBLOCK == errno || EINTR == errno) {if (wait_count < WAIT_COUNT_MAX) {wait_count++;usleep(wait_count);continue;}}}break;}if (nbytes == 0) {//fprintf(stderr, "read end\n");break;}else if (nbytes > 0) {total_len_recv += nbytes;//buffer[nbytes] = 0;//fprintf(stderr, "%s", buffer);}if ((from_server && is_server_recv_finish(total_len_recv))|| (!from_server && is_client_recv_finish(total_len_recv))) {rec_suc = 1;break;}}

        read_data行为分为客户端和服务器两个版本实现，其基本逻辑是一样的。我们考虑到读取操作可能一次性读不完，所以我们使用while循环持续尝试读取。如果是一个异步的socket，我们则考虑recv函数返回小于0时各种错误值的场景，并使用渐长等待的方式进行多次尝试。如果是同步的socket，一旦recv返回值小于0，则退出读取操作。total_len_recv函数用于统计一共读取的长度，之后通过这个长度结合是否是服务器还是客户端的标识，判断读取操作是否完成。

        当读取操作结束后，我们要统计读取操作的行为及其标识的整个过程的行为。

if (from_server) {if (rec_suc) {__sync_fetch_and_add(&g_read_suc, 1);return 0;} else {__sync_fetch_and_add(&g_read_fai, 1);__sync_fetch_and_add(&g_server_fai, 1);return -1;}} else {if (rec_suc) {__sync_fetch_and_add(&g_read_suc, 1);__sync_fetch_and_add(&g_client_suc, 1);return 0;} else {__sync_fetch_and_add(&g_read_fai, 1);__sync_fetch_and_add(&g_client_fai, 1);return -1;}}}

        如果读取操作成功，则进行发送操作。server_write方法在底层调用了write_data方法

intwrite_data(int filedes, int from_server) {int nbytes;int total_len_send;int wait_count = 0;int index;int send_suc = 0;total_len_send = 0;index = 0;while (1) {if (from_server) {nbytes = send(filedes, get_server_send_ptr(index), get_server_send_len(index), 0);}else {nbytes = send(filedes, get_client_send_ptr(index), get_client_send_len(index), 0);}if (nbytes < 0) {if (is_nonblock(filedes)) {if (EAGAIN == errno || EWOULDBLOCK == errno || EINTR == errno) {if (wait_count < WAIT_COUNT_MAX) {wait_count++;usleep(wait_count);continue;}}}break;}else if (nbytes == 0) {break;}else if (nbytes > 0) {total_len_send += nbytes;}if ((from_server && is_server_send_finish(total_len_send)) ||(!from_server && is_client_send_finish(total_len_send))){send_suc = 1;break;}}

        其实现和read_data思路一致，也考虑到一次性写不完的情况和同步异步socket问题。写入操作完成后再去统计相关行为

if (from_server) {if (send_suc) {__sync_fetch_and_add(&g_write_suc, 1);__sync_fetch_and_add(&g_server_suc, 1);return 0;} else {__sync_fetch_and_add(&g_write_fai, 1);__sync_fetch_and_add(&g_server_fai, 1);return -1;}} else {if (send_suc) {__sync_fetch_and_add(&g_write_suc, 1);return 0;} else {__sync_fetch_and_add(&g_write_fai, 1);__sync_fetch_and_add(&g_client_fai, 1);return -1;}}}

        最后我们讲下测试程序的实现。为了便于测试，我要求测试程序可以接受至少2个参数，第一个参数是用于标识启动多少个线程发送请求；第二个参数用于指定线程中等待多少毫秒发送一次请求；第三个参数是可选的，标识一共发送多少次请求。这样我们可以通过这些参数控制测试程序的行为

#define MAXREQUESTCOUNT 100000static int g_total = 0;static int g_max_total = 0;void* send_data(void* arg) {int wait_time;int client_sock;wait_time = *(int*)arg;while (__sync_fetch_and_add(&g_total, 1) < g_max_total) {usleep(wait_time);client_sock = make_client_socket();connect_server(client_sock);request_add(1);set_block_filedes_timeout(client_sock);if (0 == client_write(client_sock)) {client_read(client_sock);}close(client_sock);client_sock = 0;}}int main(int argc, char* argv[]) {int thread_count;int index;int err;int wait_time;pthread_t thread_id;if (argc < 3) {fprintf(stderr, "error! example: client 10 50\n");return 0;}err = init_print_thread();if (err < 0) {perror("create print thread error");exit(EXIT_FAILURE);}thread_count = atoi(argv[1]);wait_time = atoi(argv[2]);g_max_total = MAXREQUESTCOUNT;if (argc > 3) {g_max_total = atoi(argv[3]);}for (index = 0; index < thread_count; index++) {err = pthread_create(&thread_id, NULL, send_data, &wait_time);if (err != 0) {perror("can't create send thread");exit(EXIT_FAILURE);}}wait_print_thread();return 0;}

        线程中，首先通过make_client_socket创建socket并绑定到本地端口上

intmake_client_socket() {int client_sock = -1;struct sockaddr_in client_addr;client_sock = socket(AF_INET, SOCK_STREAM, 0);if (client_sock < 0) {perror("create socket error");exit(EXIT_FAILURE);}bzero(&client_addr, sizeof(client_addr));client_addr.sin_family = AF_INET;client_addr.sin_addr.s_addr = htons(INADDR_ANY);client_addr.sin_port = htons(0);if (bind(client_sock, (struct sockaddr*)&client_addr, sizeof(client_addr)) < 0) {perror("bind error");exit(EXIT_FAILURE);}return client_sock;}

        然后通过connect_server连接服务器

void connect_server(int client_sock) {struct sockaddr_in server_addr;bzero(&server_addr, sizeof(server_addr));server_addr.sin_family = AF_INET;if (inet_aton("127.0.0.1", &server_addr.sin_addr) == 0) {perror("set server ip error");exit(EXIT_FAILURE);}server_addr.sin_port = htons(PORT);if (connect(client_sock, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {perror("client connect server error");exit(EXIT_FAILURE);}}

        最后通过client_write和client_read和服务器通信。这两个函数都是调用上面介绍的write_data和read_data，所以没什么好讲的。

intclient_read(int filedes) {return read_data(filedes, 0);}intclient_write(int filedes) {return write_data(filedes, 0);}

        我们启动一千个线程，发送30万次请求。看看朴素模型的处理能力。

        首先我们看看服务器的结果打印

        可以发现稳定的处理能力大概在每秒14000~15000左右。

        我们再看看客户端的打印

        我们发现其发送频率差不多也是14000~16000。这儿要说明下，因为客户端是同步模型，服务器也是同步模型，所以这个速率是服务器处理的峰值。否则按照设置的1微秒的等待时间，1000个线程一秒钟发送的请求数肯定不止15000。我使用过两个测试进程同时去压，也验证了其最大的处理能力也就是在14000~15000左右（在我的配置环境下）。

        我们发现，使用朴素模型实现网络通信是非常方便的。但是这个模型有个明显的缺点，就是一次只能处理一个请求——即接收请求、读socket、写socket是串行执行的。除非使用线程池去优化这个流程，否则在单线程的情况下，似乎就不能解决这个问题了。科技总是进步的，我们将在下一节讲解Select模型，它就可以解决这个问题。