搭建一个后台服务器--服务端（异步，大并发）

from:

http://blog.csdn.net/xiaofei_hah0000/article/details/8743627

上篇的阻塞模式下服务器的并发只有几K，而真正的server 像nginx, apache, yumeiz 轻轻松松处理几万个并发完全不在话下，因此大并发的场合下是不能用阻塞的。

1W的并发是一个分隔点，如果单进程模型下能达到 的话，说明至少在服务器这块你已经很厉害了。

服务器开发就像一门气功，能不能搞出大并发，容错性处理得怎么样，就是你有没有内功，内功有多深。

异步模式是专门为大并发而生，Linux下一般用 epoll 来管理事件，下面就开始我们的异步大并发服务器实战吧。

跟阻塞开发一样，先来看看设计过程：

1.创建事件模型。

2.创建监听连接并监听。

3.将监听连接加入事件模型。

4.当有事件时，判断事件类型。

5.若事件为监听连接，则产生客户连接同时加入事件模型，对客户连接接收发送。

6.若事件为客户连接，处理相应IO请求。

为了让大家一概全貌，我用一个函数实现的( 一个函数写一个2W并发的服务器，你试过么），可读性可能会差点，但是对付这道面试题是绰绰有余了。

实际开发过程如下：

先定义一个事件结构，用于对客户连接进行缓存

 struct my_event_s
 {
     int fd;
     char recv[64];
     char send[64];

     int rc_pos;
     int sd_pos;
 };

建立缓存对象：

 struct epoll_event wait_events[ EPOLL_MAX ];
 struct my_event_s my_event[ EPOLL_MAX ];

创建监听连接：

 sock_server = socket( AF_INET, SOCK_STREAM, 0 );
 flag = fcntl( sock_server, F_GETFL, 0 );
 fcntl( sock_server, F_SETFL, flag | O_NONBLOCK );

绑定地址并监听：

 flag = bind( sock_server, ( struct sockaddr* )&addr_server, sizeof( struct sockaddr ) );
 if( flag < 0 )
 {
     printf( "your bind is not ok\n" );
     close( sock_server );
     return 0;
 }

 flag = listen( sock_server, 1024 );
 if( flag < 0 )
 {
     printf( "your listen is not ok\n");
     close( sock_server );
     return 0;
 }

创建事件模型：

 epfd = epoll_create( EPOLL_MAX );
 if( epfd <= 0 )
 {
     printf( "event module could not be setup\n");
     close( sock_server );
     return 0;
 }

将监听事件加入事件模型：

 tobe_event.events = EPOLLIN;
 tobe_event.data.fd = sock_server;

 epoll_ctl( epfd,  EPOLL_CTL_ADD, sock_server,  &tobe_event );

事件模型处理：

 e_num = epoll_wait( epfd, wait_events, EPOLL_MAX, WAIT_TIME_OUT );
 if( e_num <= 0 )
 {
     continue;
 }

 for( i = 0; i < e_num; ++i )
 {

监听处理：

 if( sock_server == wait_events[ i ].data.fd )
 {  while(1){

连接客户端：

 sock_client = accept( sock_server, ( struct sockaddr* )&addr_client, ( socklen_t*)&size );
 if( sock_client < 0 )
 {
     if( errno == EAGAIN )
     {
         break;
     }
     if( errno == EINTR )
     {
         continue;
     }
     break;
 }

将客户端连接设置为异步：

 flag = fcntl( sock_client, F_GETFL, 0 );
 fcntl( sock_client, F_SETFL, flag | O_NONBLOCK );

将客户端连接加入到 事件模型：

 tobe_event.events = EPOLLIN | EPOLLET;
 tobe_event.data.u32 = my_empty_index;

 epoll_ctl( epfd, EPOLL_CTL_ADD, sock_client, &tobe_event );

统计每秒并发数并得到系统当前时间：

 ++num;
 current = time( 0 );
 if( current > last )
 {
     printf( "last sec qps:%d\n", num );
     num = 0;
     last = current;
 }

将时间填充到连接缓存中：

 memcpy( tobe_myevent->send, ¤t, sizeof(time_t) );

接收连接内容：

 flag = recv( sock_client, tobe_myevent->recv, 64, 0 );
 if( flag < 64 )
 {
     if( flag > 0 )
         tobe_myevent->rc_pos += flag;
     continue;
 }

 if( tobe_myevent->recv[31] || tobe_myevent->recv[63] )
 {
     printf( "your recv does follow the protocal\n");
     tobe_myevent->fd = 0;
     close( sock_client );
     continue;
 }


 flag = send( sock_client, tobe_myevent->send, sizeof( time_t ), 0 );
 if( flag < sizeof( time_t ) )
 {
 "white-space:pre">  tobe_event.events =  EPOLLET | EPOLLOUT;
 "white-space:pre">  epoll_ctl( epfd, EPOLL_CTL_MOD, sock_client, &tobe_event );
     if( flag > 0 )
         tobe_myevent->sd_pos += flag;
     continue;
 }
 tobe_myevent->fd = 0;
 close( sock_client );

后面进行普通连接事件处理，错误处理：

 if( event_flag & EPOLLHUP )
 {
     tobe_myevent->fd = 0;
     close( sock_client );
     continue;
 }
 else if( event_flag & EPOLLERR )
 {
     tobe_myevent->fd = 0;
     close( sock_client );
     continue;
 }

写事件：

 else if( event_flag & EPOLLOUT )
 {
     if( tobe_myevent->rc_pos != 64 )
     {
         continue;
     }

     if( tobe_myevent->sd_pos >= sizeof( time_t ) )
     {
         tobe_myevent->fd = 0;
         close( sock_client );
         continue;
     }

     flag = send( sock_client, tobe_myevent->send + tobe_myevent->sd_pos, sizeof( time_t ) - tobe_myevent->sd_pos, 0 );
     if( flag < 0 )
     {
         if( errno == EAGAIN )
         {
             continue;
         }
         else if( errno == EINTR )
         {
             continue;
         }
         tobe_myevent->fd = 0;
         close( sock_client );
         continue;
     }

     if( flag >0 )
     {
         tobe_myevent->sd_pos += flag;
         if( tobe_myevent->sd_pos >= sizeof( time_t ) )
         {
             tobe_myevent->fd = 0;
             close( sock_client );
             continue;
         }
     }
 }

读事件：

 if( event_flag & EPOLLIN )
 {
     if( tobe_myevent->rc_pos < 64 )
     {
         flag = recv( sock_client, tobe_myevent->recv + tobe_myevent->rc_pos, 64 - tobe_myevent->rc_pos, 0 );
         if( flag <= 0 )
         {
             continue;
         }

         tobe_myevent->rc_pos += flag;

         if( tobe_myevent->rc_pos < 64 )
         {
             continue;
         }

         if( tobe_myevent->recv[31] || tobe_myevent->recv[63] )
         {
             printf( "your recv does follow the protocal\n");
             tobe_myevent->fd = 0;
             close( sock_client );
             continue;
         }

         flag = send( sock_client, tobe_myevent->send, sizeof( time_t ), 0 );
         if( flag < sizeof( time_t ) )
         {
             if( flag > 0 )
                 tobe_myevent->sd_pos += flag;
         "white-space:pre">  tobe_event.events = EPOLLET | EPOLLOUT;
             tobe_event.data.u32 = wait_events[i].data.u32;
             epoll_ctl( epfd, EPOLL_CTL_MOD, sock_client, &tobe_event );
             continue;
         }
         tobe_myevent->fd = 0;
         close( sock_client );
     }

 }

到此，一个异步服务器搭建完毕，轻松实现2W的并发量，既完成了任务，又是实实在在的锻练了一回。