上层应用程序App能够继续其它任务; 当TCP/IP协议缓冲区有数据时，Linux主动的把内核数据copy到用户空间。然后再给上层应用App发送信号；告诉App数据到来,须要处理！

   异步IO属于典型的“推模式”, 是效率最高的一种模式。上层应用程序App有异步处理的能力（在Linux内核的支持下,处理其它任务的同一时候。也可支持IO通讯, 与Windows平台下的完毕port作用相似IOCP）。

Select-I/O复用

#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);

    select实现的是一个管理者的功能: 用select来管理多个IO, 一旦当中的一个IO或者多个IO检測到我们所感兴趣的事件, select就返回, 返回值就是检測到的事件个数, 而且由第2~4个參数返回那些IO发送了事件, 这样我们就能够遍历这些事件, 进而处理这些事件;

參数:

nfds: is the highest-numbered file descriptor in any of the three sets,plus 1[读,写,异常集合中的最大文件描写叙述符+1].

fd_set[四个宏用来对fd_set进行操作]

       FD_CLR(int fd, fd_set *set);

       FD_ISSET(int fd, fd_set *set);

       FD_SET(int fd, fd_set *set);

       FD_ZERO(fd_set *set);

timeout[从调用開始到select返回前，会经历的最大等待时间, 注意此处是指的是相对时间]

//timeval结构:
struct timeval
{
    long    tv_sec;	    /* seconds */
    long	tv_usec;    /* microseconds */
};
//一些调用使用3个空的set, n为0, 一个非空的timeout来达到较为精确的sleep.

Linux中, select函数改变了timeout值。用来指示还剩下的时间，但非常多实现并不改timeout。

为了较好的可移植性，timeout在循环中一般常被又一次赋初值。

Timeout取值:

    timeout== NULL

        无限等待,被信号打断时返回-1, errno 设置成 EINTR

    timeout->tv_sec == 0 && tvptr->tv_usec == 0

        不等待马上返回

    timeout->tv_sec != 0 || tvptr->tv_usec != 0

        等待特定时间长度, 超时返回0

返回值:

  On success, select() and pselect() return the number of  file  descriptors  contained  in  

the  three  returned descriptor sets (that is, the total number of bits that are  set  in  

readfds,  writefds,  exceptfds) which  may  be  zero if the timeout expires before anything 

interesting happens.  On error, -1 is returned, and errno is set appropriately; the sets  

and  timeout  become  undefined, so do not rely on their contents after an error.

   假设成功。返回全部sets中描写叙述符的个数；假设超时。返回0；假设出错，返回-1.

/**演示样例1: 用select来改进echo回声服务器的client端的echoClient函数
使得能够在单进程的情况下同一时候监听多个文件描写叙述符;
**/
void echoClient(int sockfd)
{
    char buf[512];
    fd_set rset;
    //确保标准输入不会被重定向
    int fd_stdin = fileno(stdin);
    int maxfd = fd_stdin > sockfd ?
 fd_stdin : sockfd;
    while (true)
    {
        FD_ZERO(&rset);
        FD_SET(fd_stdin, &rset);
        FD_SET(sockfd, &rset);
        int nReady = select(maxfd+1, &rset, NULL, NULL, NULL);
        if (nReady == -1)
            err_exit("select error");
        else if (nReady == 0)
            continue;

        /** nReady > 0: 检測到了可读事件 **/

        if (FD_ISSET(fd_stdin, &rset))
        {
            memset(buf, 0, sizeof(buf));
            if (fgets(buf, sizeof(buf), stdin) == NULL)
                break;
            if (writen(sockfd, buf, strlen(buf)) == -1)
                err_exit("write socket error");
        }
        if (FD_ISSET(sockfd, &rset))
        {
            memset(buf, 0, sizeof(buf));
            int readBytes = readline(sockfd, buf, sizeof(buf));
            if (readBytes == 0)
            {
                cerr << "server connect closed..." << endl;
                exit(EXIT_FAILURE);
            }
            else if (readBytes == -1)
                err_exit("read-line socket error");

            cout << buf;
        }
    }
}

/**演示样例2: 用select来改进echo回声服务器的server端的接受连接与处理连接部分的代码:
使得能够在单进程的情况下处理多客户连接, 对于单核的CPU来说, 单进程使用select处理连接与监听套接字其效率不一定就会比多进程/多线程性能差;

**/
    struct sockaddr_in clientAddr;
    socklen_t addrLen;
    int maxfd = listenfd;
    fd_set rset;
    fd_set allset;
    FD_ZERO(&rset);
    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);

    //用于保存已连接的客户端套接字
    int client[FD_SETSIZE];
    for (int i = 0; i < FD_SETSIZE; ++i)
        client[i] = -1;
    int maxi = 0;   //用于保存最大的不空暇的位置, 用于select返回之后遍历数组

    while (true)
    {
        rset = allset;
        int nReady = select(maxfd+1, &rset, NULL, NULL, NULL);
        if (nReady == -1)
        {
            if (errno == EINTR)
                continue;
            err_exit("select error");
        }
        //nReady == 0表示超时, 可是此处是一定不会发生的
        else if (nReady == 0)
            continue;

        if (FD_ISSET(listenfd, &rset))
        {
            addrLen = sizeof(clientAddr);
            int connfd = accept(listenfd, (struct sockaddr *)&clientAddr, &addrLen);
            if (connfd == -1)
                err_exit("accept error");

            int i;
            for (i = 0; i < FD_SETSIZE; ++i)
            {
                if (client[i] < 0)
                {
                    client[i] = connfd;
                    if (i > maxi)
                        maxi = i;
                    break;
                }
            }
            if (i == FD_SETSIZE)
            {
                cerr << "too many clients" << endl;
                exit(EXIT_FAILURE);
            }
            //打印客户IP地址与port号
            cout << "Client information: " << inet_ntoa(clientAddr.sin_addr)
                 << ", " << ntohs(clientAddr.sin_port) << endl;
            //将连接套接口放入allset, 并更新maxfd
            FD_SET(connfd, &allset);
            if (connfd > maxfd)
                maxfd = connfd;

            if (--nReady <= 0)
                continue;
        }

        /**假设是已连接套接口发生了可读事件**/
        for (int i = 0; i <= maxi; ++i)
            if ((client[i] != -1) && FD_ISSET(client[i], &rset))
            {
                char buf[512] = {0};
                int readBytes = readline(client[i], buf, sizeof(buf));
                if (readBytes == -1)
                    err_exit("readline error");
                else if (readBytes == 0)
                {
                    cerr << "client connect closed..." << endl;
                    FD_CLR(client[i], &allset);
                    close(client[i]);
                    client[i] = -1;
                }
                //注意此处: Server从Client获取数据之后并没有马上回射回去,
                //        而是等待四秒钟之后再进行回射
                sleep(4);
                cout << buf;
                if (writen(client[i], buf, readBytes) == -1)
                    err_exit("writen error");

                if (--nReady <= 0)
                    break;
            }
    }

完整源码请參照:

http://download.csdn.net/detail/hanqing280441589/8486517