Linux网络编程（3）使用select处理多个连接的回射服务器

作为一个服务器，只处理一个连接是在有点说不过去。当有多个客户端建立连接时，需要保持较好的并发性，以及时处理每个连接。

最简单的一种方法就是把socket设置为非阻塞方式（使用ioctl()函数），然后在一个死循环中一直轮流测试每个连接的recv()，如果收到数据，再发送回去。这样做最大的坏处就是在没有可以读的数据时，CPU一直处于忙等待的状态，浪费了宝贵的CPU资源。

有一种不使用忙等待的方法，那就是对于每个连接，都在一个子线程或者子进程中来进行IO操作，主线程或者主进程只负责accept()，每当有新的连接建立时，新建一个子线程或者子进程，把这个连接的socket描述符传给它。这样做保持了很好的并发性。用子线程来代替子进程当然是更好的选择，因为它占用更少的资源，而且线程之间可以方便的使用共享的内存。但是这样做也有不足的地方，就是当连接数非常大时，比如说几千个或者上万个，线程之间的切换则会造成不小的代价。如果一个服务器只需要维护很少的连接，比如几个或者十几个，使用这种方法还是比较可行的。

还有一种方法，也就是下面详细介绍的方法，I/O复用的一种：使用select()函数。整个过程可以先大致这么理解：有三个socket描述符集合，分别代表可以读的描述符，可以写的描述符，和有待处理异常的描述符。调用select()函数之前，先把需要关注的描述符放入对应的描述符集合里，然后调用select()，返回时，依次检查每个描述符，看看它是否可读或者可写或者有异常。如果所有描述符都没有准备就绪，select()函数默认会一直阻塞。

下面介绍一下相关的函数和数据结构：

#include <sys/select.h>
#include <sys/time.h>
int select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, const struct timeval *timeout);

struct timeval
{
	long tv_sec;
	long tv_usec;
}

void FD_ZERO(fd_set *fdset);
void FD_SET(int fd, fd_set *fdset);
void FD_CLR(int fd, fd_set *fdset);
int FD_ISSET(int fd, fd_set *fdset);

如果有描述符准备好了，select()函数返回描述符的个数， 超时返回0， 出错返回-1。第一个参数maxfdp1的值是待测试的最大描述符加1，它代表这一次select()函数需要测试的描述符的个数（后面还会再解释这个参数的含义）。第二、三、四个参数分别代表程序关注的可读、可写和有异常的描述符的指针。第四个参数指向一个timeval结构体，它代表了select的超时时间。timeval的第一个成员代表秒，第二个成员代表微秒。readset，writeset和exceptest，如果我们对某个集合不感兴趣，就把它设置为NULL。如果这三个参数都是NULL，那么select()函数就成了一个微秒级别的定时器。如果timeout设置为NULL，则select()函数会永远等待下去。如果把timeval的两个成员都设置为0，则select()函数会立刻返回。

FD_ZERO()、FD_SET()、FD_CLR()、FD_ISSET()这四个宏函数分别提供了把fd_set的所有位置零、设置fd_set的某一位为一、把fd_set的某一位清零和检测fd_set的某一位是否是1。fd_set可以理解成是一个比特数组，每一个比特代表一个描述符。每个描述符根据它的值被映射到相应的比特上。fd_set一般最多可以放置1024个描述符，也就是说fd_set一共有1024比特。select()函数会测试fd_set中前maxfdp1个比特，看它们是否准备好。剩下的比特就不用再检测了，可以提高效率。这就很好解释maxfdp1这个参数的含义了，因为描述符的值是从0开始的。举个例子，比如有3个需要测试是否可读的描述符，它们的值分别为1，3，5，那么fd_set的前6位分别为010101（注意，描述符是从0开始编号的），select需要依次检测6个描述符，即从0至5，所以maxfdp1的值是最大的描述符的值（5）加一。

select()函数返回后，会把满足条件的描述符所对应的比特置为1，不满足的置为0。使用FD_ISSET()宏函数一次检测每个描述符，就可以知道哪个描述符准备好了，并对它进行对应的操作。有一点需要注意，每次调用select()函数之前，fd_set都必须重新设定，因为select()函数会修改fd_set中的比特。

下面简单介绍一下可读、可写和有异常的定义。

可读的4种定义：（1）套接字缓冲区收到了足够的数据（和TCP的实现有关），也就是说这时调用recv()函数不会阻塞，而且返回一个大于0的值。（2）套接字的读半部被关闭，也就是说它收到了一个FIN标志。此时调用recv()函数返回0。（3）在服务器端套接字成功开始监听，并且完成了至少1个连接。也就是说这时调用accept()函数不会阻塞。（4）有一个套接字出错了，这时调用recv()函数则返回-1。

可写的4中定义：（1）套接字的发送缓冲区有足够的空间接收数据此时调用send()函数不会阻塞且返回一个大于0的值。（2）套接字的写半部被关闭。（3）非阻塞的connect()函数成功建立了连接，或者失败。（4）有一个套接字出错了，这时调用send()函数则返回-1。

有异常的定义：TCP有带外数据。

下面的程序是使用了select()函数的回射服务器程序。为了使用STL提供的set，map等数据结构，这次使用C++，但是没有用到面向对象编程。

#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/select.h>
#include <string.h>
#include <string>
#include <set>
#include <map>
#include <iostream>

using namespace std;

#define BUFFER_SIZE 1024

int getSetMax(set<int> &s)
{
    if(s.empty() == true)
        return 0;
    int max = (*(s.begin()));
    set<int>::iterator it;
    for(it = s.begin(); it != s.end(); it++)
        if((*it) > max)
            max = (*it);
    return max;
}

int getMapMax(map<int, string> &m)
{
    if(m.empty() == true)
        return 0;
    map<int, string>::iterator it;
    int max = m.begin()->first;
    for(it = m.begin(); it != m.end(); it++)
        if(it->first > max)
            max = it->first;
    return max;
}

int main(int argc, char** argv)
{
    if(argc != 2)
    {
        cout<<"Usage:"<<endl<<argv[0]<<" <port>"<<endl;
        return 0;
    }
    char buffer[BUFFER_SIZE];
    int socketFd, clientFd;
    unsigned int clientAddrLength;
    int receivedLength;
    struct sockaddr_in myAddr;
    struct sockaddr_in clientAddr;
    fd_set readSet;
    fd_set writeSet;
    set<int> socketSet;
    map<int, string> receivedMessages;

    memset(&myAddr, 0, sizeof(myAddr));
    myAddr.sin_family = AF_INET;
    myAddr.sin_port = htons(atoi(argv[1]));
    myAddr.sin_addr.s_addr = htonl(INADDR_ANY);

    socketFd = socket(AF_INET, SOCK_STREAM, 0);
    bind(socketFd, (struct sockaddr*)&myAddr, sizeof(myAddr));
    listen(socketFd, 8);

    set<int>::iterator it;
    map<int, string>::iterator mapIt;
    while(true)
    {
        FD_ZERO(&readSet);
        FD_SET(socketFd, &readSet);
        for(it = socketSet.begin(); it != socketSet.end(); it++)
            FD_SET((*it), &readSet);
        select(max(getSetMax(socketSet), socketFd) + 1, &readSet, NULL, NULL, NULL);
        if(FD_ISSET(socketFd, &readSet))
        {
            clientAddrLength = sizeof(clientAddr);
            clientFd = accept(socketFd, (struct sockaddr*)&clientAddr, &clientAddrLength);
            cout<<"Accept a connection: "
                + string(inet_ntoa(clientAddr.sin_addr)) + ':'
                <<ntohs(clientAddr.sin_port)<<endl;
            socketSet.insert(clientFd);
        }
        for(it = socketSet.begin(); it != socketSet.end(); it++)
        {
            if(FD_ISSET((*it), &readSet))
            {
                receivedLength = recv((*it), buffer, BUFFER_SIZE, 0);
                if(receivedLength <= 0)
                {
                    shutdown((*it), SHUT_RDWR);
                    socketSet.erase(*it);
                    receivedMessages.erase(*it);
                }
                else
                {
                    buffer[receivedLength] = '\0';
                    cout<<"Receive a message: "<<buffer<<endl;
                    receivedMessages[*it].append(string(buffer, receivedLength));
                }
            }
        }
        if(receivedMessages.empty() == false)
        {
            FD_ZERO(&writeSet);
            for(mapIt = receivedMessages.begin();
                mapIt != receivedMessages.end(); mapIt ++)
                FD_SET(mapIt->first, &writeSet);
            select(getMapMax(receivedMessages) + 1, NULL, &writeSet, NULL, NULL);
            for(mapIt = receivedMessages.begin();
                mapIt != receivedMessages.end(); mapIt ++)
            {
                if(FD_ISSET(mapIt->first, &writeSet))
                {
                    send(mapIt->first, mapIt->second.c_str(), mapIt->second.length(), 0);
                    receivedMessages.erase(mapIt);
                }
            }
        }
    }

    return 0;
}

可以多开几个netcat测试一下，或者写个脚本测试一下。

上面这个程序是在单线程下使用select来处理多个TCP连接的。现代CPU都有多个核心，所以使用多线程可以很大地提升性能。在主线程中只用select()函数测试已建立的连接，然后看一看子线程中哪个线程的可读描述符集合最小，就把新的描述符传给它。在子线程里，先等待有可读的描述符，收到数据后再把数据发送给可写的描述符。但是建立多少个线程最合适？我认为子线程个个数应该是CPU物理核心数的2倍。因为超线程技术可以使单个核心的并行性能得到提升。