linux socke编程实例：一个简单的echo服务器程序(2)

    在文章 ＜＜linux socke编程实例：一个简单的echo服务器程序＞＞简单地介绍了如何在linix使用socket进行网络编程，并且在文中给出相应的程序和说明，以使大家对socket编程有初步的了解。现在我们解决文中出现的问题：不能同时与多个客户进行通信，只能第一个客户通信结束事才能与第二个客户进行通信，依次...直到有的客户连接超时，或者没有客户进行连接。通常一个服务器程序应能同时与多个客户端进行通信，能及时对它的请求作出回复。
   其实这个问题有很多解方案，最明显的一种就是采用多线程或者采用多进程。显然多进程是不可取的，因此有多线程的存。采用多线程技术时，每当有客户请求连接，服务器都是新建一个线程与之通信，通信完成后将终止该线程。这样的情况适合于大量IO操作的服务器程程，或者服务器的是多核的。否则，这样未免太浪费了，系统的开销也会很大。因此我们致力于采用单进程单线的解决方案。
   其实，我们对C/S通信方式中的服务器端会有这样的直觉：服务器等待客户的到来，如果在一定的时间内（10ms），如果没有收到请求，那就不等了，马上回来处量已连接上的客户端，并与之通信。与已连接上的客户端进行通信，也采用这样的方式，对于任一客户端，看它有没有数据到来，有则处理，没则轮到下一个客户，采用相同的处理方式。依次进行下去，就不需要使用多进程或多线程技术，可以如何实现呢？

    其实IO可以分为阻塞IO和非阻塞IO，当读阻塞IO的数据时，直到有数据时才返回，否则一直阻塞；非阻塞IO却不同，读非阻塞IO的数据时，不管有没有数据到来，它都会及时返回，有 没 有数据到来依据返回值进行判断。无论我们在代码中使用open还是socket函数返回的文件描述符，它都是阻塞的，要使它变为非阻塞，则必须使用fcntl函数对它的属性进行更改。fcntl函数说明如下：

int  fcntl( int fd int  cmd,... /*  int arg * / ) ;

fd为文件描述符，cmd表示命令，可变参数的个数和类型根据cmd值的不同而不同。

f c n t l函数有五种功能：
复制一个现存的描述符（cmd＝F_DUPFD）。
获得/设置文件描述符标记（cmd = F_GETFD或F_SETFD）。
获得/设置文件状态标志（cmd = F_GETFL或F_SETFL）。
获得/设置异步I / O有权（cmd = F_GETOWN或F_SETOWN）。
获得/设置记录锁（cmd = F_GETLK , F_SETLK或F_SETLKW）。
要设置文件的非阻塞属生，先要用cmd=F_GETFD获得属性值，然后把属性值为非阻塞的即可。

为了方便设置文件的属生，我们定义了如下的函数：

void  set_fl( int  fd,  int  flags)
... {
    int val;
    //获取属性
    if((val = fcntl(fd, F_GETFL, 0)) < 0)
    ...{
        printf("get socket property error ");
        exit(0);
    }
    //更改属性
    val = val |flags;
    //更改属性后再设置，以使它使效
    if(fcntl(fd, F_SETFL, val) < 0)
    ...{
        printf("set socket property error ");
        exit(1);
    }
}

在函数set_fl中，可以对文件fd设置属性flags，如果我们要把描述符socketfd设置为非阻塞，只需如下语句即可：

set_fl(socketfd, O_NONBLOCK);

下面是采用非阻塞IO机制来实现的代码，与原来的相比，结构和原理上没有改变，只是把所有的IO都设置为非阻塞的。

#include  < netdb.h >
#include  < sys / socket.h >
#include  < errno.h >
#include  < stdio.h >
#include  < unistd.h >
#include  < fcntl.h >

#define  EHCO_PORT    8080
#define  MAX_CLIENT_NUM        100

void  set_fl( int  fd,  int  flags)
{
     int  val;
     if ((val  =  fcntl(fd, F_GETFL,  0 ))  <   0 )
    {
        printf( " get socket property error " );
        exit( 0 );
    }
    val  =  val  | flags;
     if (fcntl(fd, F_SETFL, val)  <   0 )
    {
        printf( " set socket property error " );
        exit( 1 );
    }
}

int  main()
{
     int  socketfd;
    socketfd  =  socket(AF_INET, SOCK_STREAM,  0 );
       
     if (socketfd  ==   - 1 )
    {
        printf( " errno=%d " , errno);
        exit( 1 );
    }
     else
    {
        printf( " socket create successfully " );
    }

     struct  sockaddr_in sa;
    bzero( & sa,  sizeof (sa));
    sa.sin_family  =  AF_INET;
    sa.sin_port  =  htons(EHCO_PORT);
    sa.sin_addr.s_addr  =  htons(INADDR_ANY);
    bzero( & (sa.sin_zero),  8 );

     if (bind(socketfd, ( struct  sockaddr  * ) & sa,  sizeof (sa)) !=   0 )
    {
        printf( " bind failed " );
        printf( " errno=%d " , errno);
        exit( 1 );
    }
     else
    {
        printf( " bind successfully " );
    }

     // listen
     if (listen(socketfd ,MAX_CLIENT_NUM)  !=   0 )
    {
        printf( " listen error " );
        exit( 1 );
    }
     else
    {
        printf( " listen successfully " );
    }

     int  clientfd;
     struct  sockaddr_in clientAdd;
    socklen_t len  =   sizeof (clientAdd);

     char  buff[ 100 ];
     int  closing  = 0 ;
     int  clientArray[MAX_CLIENT_NUM];
     int  i;
     for (i  =   0 ; i  <  MAX_CLIENT_NUM;  ++ i)
    {
        clientArray[i]  =   - 1 ;     //  -1 indicates no using
    }
   
    // set no blocking for server, and the accept function will not block.
    set_fl(socketfd, O_NONBLOCK);

     while ( closing  ==   0   )
    {
        clientfd  =  accept(socketfd, ( struct  sockaddr  * ) & clientAdd,  & len);
        
         if (clientfd  >   0 )
        {
            printf( " receive connection " );
            //set no blocking for client, in that the read function will no block.
            set_fl(clientfd, O_NONBLOCK);
             for (i  =   0 ; i  <  MAX_CLIENT_NUM;  ++ i)
            {
                 if (clientArray[i]  ==   - 1 )
                {
                    clientArray[i]  =  clientfd;
                     break ;
                }
            }
             if (i  ==  MAX_CLIENT_NUM)
            {
                 // there is not enough sockets for client, so close it
                close(clientfd);
            }
        }
        
         int  n;

         for (i  =   0 ; i  <  MAX_CLIENT_NUM;  ++ i)
        {
             if (clientArray[i]  ==   - 1 )  continue ;
             if ( (n  =  recv(clientArray[i], buff,  100 ,  0 ))  >   0 )
            {
                printf( " number of receive bytes = %d " , n);
                write(STDOUT_FILENO, buff, n);
                send(clientArray[i],buff, n,  0 );
                buff[n]  = 0 ;
                 if (strcmp(buff,  " quit/r/n " )  ==   0 )
                {
                    close(clientArray[i]);
                    clientArray[i]  =   - 1 ;
                     break ;
                }
                 else   if (strcmp(buff,  " close /r/n" )  ==   0 )
                {
                     // server closing
                    closing  =   1 ;
                    printf( " server is closing " );
                     break ;
                }
            }
        }
         // printf("receive finsihed ");
        
    }

     for (i  =   0 ; i  <  MAX_CLIENT_NUM;  ++ i)
    {
         if (clientArray[i]  !=   - 1 )
        {
            close(clientArray[i]);    
        }
    }
    close(socketfd);

     return   0 ;
}

    值得一提的是，当文件为非阻塞时，accept会回返回它接受连接的客户端描述符，如没有客户请求连接，则返回-1；同理,recv会返回该客户端发送过来的数据的字节数，如没有数据到来，则返回-1。因此我们可以根据这两个函数的返回值进行相应的操作。accept返回非负数的情况，说明有新的客户请求连接，因此要把它记录下来，以下次能收到它发送过来的信息。对于recv也一样，如果返回值为正数，则说明有数所到来，对数据作相应的处理返回复。
    经此一役，使用单进程的通信方式仍然可以实现服务器程序。可以使用上文中介绍的方法（telnet）对它进行测试。

    在测试的过程中，我们依然可以发现：服务器采用了非阻塞的方式进行读，当没有数据准备好的时候，它不停地循环，这样浪费了大量的CPU时间。因此，本文的方案仍不是一个最好的方案。
   如果客户端的通信量很少，那么服务器会不停地循环，这样就会占用很多CPU时间，使得其它进程使用的时间很少。
   如果解决这个问题呢？在下一篇章和大家一起探讨一下解决的方法。