Linux Network IO Model Learning

0. 引言
1. IO机制简介
2. 阻塞式IO模型(blocking IO model)
3. 非阻塞式IO模型(noblocking IO model)
4. IO复用式IO模型(IO multiplexing model)
5. 信号驱动式IO模型(signal-driven IO model)
6. 异步IO式IO模型(asynchronous IO model)
7. Linux下IO技术简介
8. IO模型编程举例

1. IO模式
所谓是一种理论模型，是一种思想
2. IO技术(机制)
指linux下具体的IO通信技术

1. File System(文件系统)
解决了空间管理的问题，即
    1) 数据如何存放
    2) 数据如何读取

2. Buffer Cache
解决数据缓冲的问题
    1) 对读，进行cache
    缓存经常要用到的数据
    2) 对写，进行buffer
    缓冲一定数据以后，一次性进行写入

3. Vol Mgmt
VM(Vol Mgmt)其实跟IO没有必然联系。他是处于文件系统和磁盘(存储)中间的一层。VM屏蔽了底层磁盘对上层文件系统的影响。当没有VM的时候，文件系统直接使用存储上的地址空间，因此文件系统直接受限于物理硬盘，这时如果
发生磁盘空间不足的情况，对应用而言将是一场噩梦，不得不新增硬盘，然后重新进行数据复制。而VM则可以实现动态扩展，而对文件系统没有影响。另外，VM也可以把多个磁盘合并成一个磁盘，对文件系统呈现统一的地址空间 

/*
数据实际存储
数据最终会放在这里，因此，效率、数据安全、容灾是这里需要考虑的问题。而提高存储的性能，则可以直接提高物理IO的性能
*/
4. Device Driver
5. IO Channel
6. Disk Device

//逻辑IO和物理IO不是一一对应的
1. Logical IO 
逻辑IO是操作系统发起的IO，这个数据可能会放在磁盘上，也可能会放在内存(文件系统的Cache)里

2. Physical IO
物理IO是设备驱动发起的IO，这个数据最终会落在磁盘上 

1. 等待资源阶段(排队)
IO请求一般需要请求特殊的资源(如磁盘、RAM、文件)，当资源被上一个使用者使用没有被释放时，IO请求就会被阻塞，直到能够使用这个资源(阻塞条件解除)
在等待数据阶段，IO分为阻塞IO和非阻塞IO
    1.1 阻塞IO
    资源不可用时，IO请求一直阻塞，直到反馈结果(有数据或超时)
    1.2 非阻塞IO(返回失败)
    资源不可用时，IO请求离开返回，返回数据标识资源不可用
    1.3 非阻塞IO(异步回调)
    资源不可用时，IO请求离开返回，返回数据标识资源不可用，但使用注册回调机制，当资源可用时由资源方主动向资源请求方发出通知信号(表明资源可用)

2. 使用资源阶段(服务)
真正进行数据接收和发生
在使用资源阶段，IO分为同步IO和异步IO
    2.1 同步IO
    应用阻塞在发送或接收数据的状态，直到数据成功传输或返回失败
    2. 异步IO
    应用发送或接收数据后立刻返回，数据写入OS缓存，由OS完成数据发送或接收，并返回成功或失败的信息给应用

1. 阻塞式IO模型(blocking IO model) 
2. 非阻塞式IO模型(noblocking IO model)
3. IO复用式IO模型(IO multiplexing model)
4. 信号驱动式IO模型(signal-driven IO model) 
5. 异步IO式IO模型(asynchronous IO model)

1. 同步异步标准是
数据描述符缓存是由谁来进行读取的
    1) 由用户程序读取: 则判断为同步
    2) 由内核推送: 判断为异步

2. 阻塞非阻塞标准是
调用的用户进程是否是阻塞的状态
    1) 资源请求方的用户进程处于阻塞状态(发出调用后阻塞等待): 阻塞式IO
    2) 资源请求方的用户进程处于非阻塞状态(发出调用后立即返回): 非阻塞式IO

1. 阻塞IO
使用简单，但随之而来的问题就是会形成阻塞，需要独立线程配合，而这些线程在大多数时候都是没有进行运算的。Java的BIO使用这种方式，问题带来的问题很明显，一个Socket需要一个独立的线程，因此，会造成线程膨胀

2. 非阻塞IO
采用轮询方式，不会形成线程的阻塞。Java的NIO使用这种方式，对比BIO的优势很明显，可以使用一个线程进行所有Socket的监听(select)，大大减少了线程数。
 
3. 同步IO
同步IO保证一个IO操作结束之后才会返回，因此同步IO效率会低一些，但是对应用来说，编程方式会简单。Java的BIO和NIO都是使用这种方式进行数据处理

4. 异步IO
由于异步IO请求只是写入了缓存，从缓存到硬盘是否成功不可知，因此异步IO相当于把一个IO拆成了两部分，一是发起请求，二是获取处理结果。因此，对应用来说增加了复杂性。但是异步IO的性能是所有很好的，而且异步的思想贯穿了
IT系统方方面面

http://pengjiaheng.iteye.com/blog/847588
http://pengjiaheng.iteye.com/blog/847615
unix网络编程 (1).pdf 6.2节
http://www.cnblogs.com/yjf512/archive/2012/05/29/2523692.html
http://www.360doc.com/content/12/0426/15/507289_206688978.shtml
http://blog.chinaunix.net/uid-26000296-id-4100620.html

1. 首先application调用recvfrom()转入kernel，注意kernel有2个过程
    1) wait for data
    2) copy data from kernel to user
2. 直到最后copy complete后
3. recvfrom()才返回
4. 此过程一直是阻塞的

http://blog.csdn.net/shallwake/article/details/5265287

http://blog.csdn.net/shallwake/article/details/5265287

http://www.cnblogs.com/yjf512/archive/2012/05/31/2527966.html
http://www.blogjava.net/lihao336/archive/2009/12/27/307430.html

1. 应用程序调用read命令，通知内核需要做读取数据操作
2. 内核创建一个文件描述符
3. 内核从物理层收到读数据的命令，从网络中获取数据包
4. 数据包传递到TCP/IP层，解析数据包的头
5. 内核将数据包缓存在文件描述符的读缓存区(接受缓存区)中，注意这里的读缓存区是在内核中的
6. 当文件描述符读缓存区数据字节数大于应用程序定义的低水位(阈值)的时候(read的一个参数)，此时文件描述符处于读就绪的状态
7. 将读缓存区中的数据复制到应用程序(用户区)返回

1. 每个文件描述符都有自己的读缓冲区和写缓冲区，读缓冲区对应的是read操作，写缓冲区对应的就是write操作了
2. 读缓冲区和写缓冲区都是在内核区中

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netdb.h>
#include <string.h>
#define SERVPORT 80
#define MAXDATASIZE 100


int main(int argc, char *argv[])
{
    int sockfd, recvbytes;
    char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */
    char snd_buf[MAXDATASIZE];
    struct hostent *host;             

    /* struct hostent
    * {
    * char *h_name; // general hostname
    * char **h_aliases; // hostname‘s alias
    * int h_addrtype; // AF_INET
    * int h_length; 
    * char **h_addr_list;
    * };
    */

    struct sockaddr_in server_addr;


    if (argc < 3)
    {
        printf("Usage:%s [ip address] [any string]\n", argv[0]);
        return 1;
    } 

    *snd_buf = ‘\0‘;
    strcat(snd_buf, argv[2]);


    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("socket:");
        exit(1);
    } 

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVPORT);
    inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
    memset(&(server_addr.sin_zero), 0, 8); 

    /* create the connection by socket 
    * means that connect "sockfd" to "server_addr"
    * 同步阻塞模式 
    */
    if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    {
        perror("connect");
        exit(1);
    } 

    /* 同步阻塞模式  */
    if (send(sockfd, snd_buf, sizeof(snd_buf), 0) == -1)
    {
        perror("send:");
        exit(1);
    }
    printf("send:%s\n", snd_buf);


    /* 同步阻塞模式  */
    if ((recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, 0)) == -1)
    {
        perror("recv:");
        exit(1);
    } 

    rcv_buf[recvbytes] = ‘\0‘;
    printf("recv:%s\n", rcv_buf); 

    close(sockfd);
    return 0;
}

1. 优势
在于非常简单，等待的过程中占用的系统资源微乎其微，程序调用返回时，必定可以拿到数据

2. 缺点
程序在数据到来并准备好以前，不能进行其他操作，需要有一个线程专门用于等待，这种代价对于需要处理大量连接的服务器而言，是很难接受的

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

#define SERVPORT 80
#define MAXDATASIZE 100

int main(int argc, char *argv[])
{
    int sockfd, recvbytes;
    char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */
    char snd_buf[MAXDATASIZE];
    struct hostent *host; 
    
    /* struct hostent
    * {
    * char *h_name; // general hostname
    * char **h_aliases; // hostname‘s alias
    * int h_addrtype; // AF_INET
    * int h_length; 
    * char **h_addr_list;
    * };
    */

    struct sockaddr_in server_addr;
    int flags;
    int addr_len; 

    if (argc < 3)
    {
        printf("Usage:%s [ip address] [any string]\n", argv[0]);
        return 1;
    } 

    *snd_buf = ‘\0‘;
    strcat(snd_buf, argv[2]); 

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("socket:");
        exit(1);
    }
 
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVPORT);
    inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
    memset(&(server_addr.sin_zero), 0, 8);
    addr_len = sizeof(struct sockaddr_in); 

    /* Setting socket to nonblock */
    flags = fcntl(sockfd, F_GETFL, 0);
    fcntl(sockfd, flags|O_NONBLOCK); 

    /* create the connection by socket 
    * means that connect "sockfd" to "server_addr"
    * 同步阻塞模式  
    */
    if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    {
        perror("connect");
        exit(1);
    } 

    /* 同步非阻塞模式 */
    while (send(sockfd, snd_buf, sizeof(snd_buf), MSG_DONTWAIT) == -1)
    {
        sleep(10);
        printf("sleep\n");
    }
    printf("send:%s\n", snd_buf);

    /* 同步非阻塞模式 */
    while ((recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, MSG_DONTWAIT)) == -1)
    {
        sleep(10);
        printf("sleep\n");
    } 

    rcv_buf[recvbytes] = ‘\0‘;
    printf("recv:%s\n", rcv_buf); 

    close(sockfd);
    return 0;
}

while(1)
{
    非阻塞read(设备1);
    if(设备1有数据到达)
        处理数据;

    非阻塞read(设备2);
    if(设备2有数据到达)
        处理数据; 
    ..............................
}

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/time.h>
#include <netdb.h>
#include <string.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define SERVPORT 80
#define MAXDATASIZE 100
#define TFILE "data_from_socket.txt"

int main(int argc, char *argv[])
{
    int sockfd, recvbytes;
    char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */
    char snd_buf[MAXDATASIZE];
    struct hostent *host;             
    /* struct hostent
    * {
    * char *h_name; // general hostname
    * char **h_aliases; // hostname‘s alias
    * int h_addrtype; // AF_INET
    * int h_length; 
    * char **h_addr_list;
    * };
    */
    struct sockaddr_in server_addr;

    /* */
    fd_set readset, writeset;
    int check_timeval = 1;
    struct timeval timeout={check_timeval,0}; //阻塞式select, 等待1秒，1秒轮询
    int maxfd;
    int fp;
    int cir_count = 0;
    int ret;

    if (argc < 3)
    {
        printf("Usage:%s [ip address] [any string]\n", argv[0]);
        return 1;
    }

    *snd_buf = ‘\0‘;
    strcat(snd_buf, argv[2]);

    if ((fp = open(TFILE,O_WRONLY)) < 0)    //不是用fopen
    {
        perror("fopen:");
        exit(1);
    }

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("socket:");
        exit(1);
    }

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVPORT);
    inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
    memset(&(server_addr.sin_zero), 0, 8);


    /* create the connection by socket 
    * means that connect "sockfd" to "server_addr"
    */
    if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    {
        perror("connect");
        exit(1);
    }
 
    /**/
    if (send(sockfd, snd_buf, sizeof(snd_buf), 0) == -1)
    {
        perror("send:");
        exit(1);
    }
    printf("send:%s\n", snd_buf);

    while (1)
    {
        FD_ZERO(&readset);            //每次循环都要清空集合，否则不能检测描述符变化
        FD_SET(sockfd, &readset);     //添加描述符       
        FD_ZERO(&writeset);
        FD_SET(fp, &writeset); 

        maxfd = sockfd > fp ? (sockfd+1) : (fp+1);    //描述符最大值加1 

        ret = select(maxfd, &readset, NULL, NULL, NULL);   // 阻塞模式
        switch( ret)
        {
            case -1:
                exit(-1);
                break;
            case 0:
                break;
            default:
                if (FD_ISSET(sockfd, &readset))  //测试sock是否可读，即是否网络上有数据
                {
                    recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, MSG_DONTWAIT);
                    rcv_buf[recvbytes] = ‘\0‘;
                    printf("recv:%s\n", rcv_buf); 

                    if (FD_ISSET(fp, &writeset))
                    {
                        write(fp, rcv_buf, strlen(rcv_buf));   // 不是用fwrite
                    }
                    goto end;
                }
        }
        cir_count++;
        printf("CNT : %d \n",cir_count);
    }
 
    end:
    close(fp);
    close(sockfd); 

    return 0;
}
 


perl实现:
#! /usr/bin/perl
###############################################################################
# \File
#  tcp_client.pl
# \Descript
#  send message to server
###############################################################################
use IO::Socket;
use IO::Select;
 

#hash to install IP Port
%srv_info =(
#"srv_ip"  => "61.184.93.197",
"srv_ip"  => "192.168.1.73",
"srv_port"=> "8080",
);

my $srv_addr = $srv_info{"srv_ip"};
my $srv_port = $srv_info{"srv_port"};

my $sock = IO::Socket::INET->new(
PeerAddr => "$srv_addr",
PeerPort => "$srv_port",
Type     => SOCK_STREAM,
Blocking => 1,
#     Timeout  => 5,
Proto    => "tcp")
or die "Can not create socket connect. $@";

$sock->send("Hello server!\n", 0) or warn "send failed: $!, $@";
$sock->autoflush(1);

my $sel = IO::Select->new($sock);
while(my @ready = $sel->can_read)
{
    foreach my $fh(@ready)
    {
        if($fh == $sock)
        {
            while()
            {
                print $_;
            }
            $sel->remove($fh);
            close $fh;
        }
    }
}
$sock->close();

1. 首先开启套接口的信号驱动 I/O功能，并通过sigaction系统调用安装一个信号处理函数
2. 该系统调用将立即返回，我们的进程继续工作，也就是说没被阻塞
3. 当数据报准备好读取时，内核就为该进程产生一个SIGIO信号
4. 我们随后既可以在信号处理函数中调用recvfrom读取数据报，并通知主循环数据已准备好待处理，也可以立即通知主循环，让它读取数据报

#include <stdio.h> 
#include <sys/types.h>
#include <sys/socket.h> 
#include <netinet/in.h>  
#include <string.h> 
#include <unistd.h>  
#include <signal.h> 
#include <fcntl.h> 
 
int listenfd1;
 
void do_sigio(int sig)
{
    int clifd, clilen;
    struct sockaddr_in cli_addr;
    char buffer[256];

    clifd = accept(listenfd1, (struct sockaddr *) &cli_addr, &clilen);
    bzero(buffer, 256);
    read(clifd, buffer, 255);
    printf("Listenfd1 Message%s\r\n", buffer);
}
 
int main(int argc, char *argv[])
{
    //绑定监听7779端口的fd
    struct sockaddr_in serv_addr1;
    listenfd1 = socket(AF_INET, SOCK_DGRAM, 0);

    bzero((char *) &serv_addr1, sizeof(serv_addr1));
    serv_addr1.sin_family = AF_INET;
    serv_addr1.sin_port = htons(7779);
    serv_addr1.sin_addr.s_addr = INADDR_ANY;

    struct sigaction sigio_action;
    memset(&sigio_action, 0, sizeof(sigio_action));
    sigio_action.sa_flags = 0;
    sigio_action.sa_handler = do_sigio;
    sigaction(SIGIO, &sigio_action, NULL);

    fcntl(listenfd1, F_SETOWN, getpid());
    int flags;
    flags = fcntl(listenfd1, F_GETFL, 0);
    flags |= O_ASYNC | O_NONBLOCK;
    fcntl(listenfd1, F_SETFL, flags);

    bind(listenfd1, (struct sockaddr *) &serv_addr1, sizeof(serv_addr1));

    while(1);
    close(listenfd1);

    return 0; 
} 

//客户端 
#include <stdio.h>  
#include <sys/socket.h>  
#include <sys/types.h>  
#include <netinet/in.h> 
#include <string.h> 
#include <unistd.h>
 
int main(int argc, char* argv[])
{
    int socketfd, n;
    socketfd = socket(AF_INET, SOCK_DGRAM, 0);

    struct sockaddr_in serv_addr;
     
    bzero((char *)&serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(7779);
     
    connect(socketfd,(struct sockaddr *)  &serv_addr, sizeof(serv_addr));
     
    write(socketfd, "client message", 14);
    return 0;
 
}

1. 信号驱动I/O是由内核通知我们何时可以启动一个I/O操作
2. 异步I/O模型是由内核通知我们I/O操作何时完成(是一种等待模式的完全解放)

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/time.h>
#include <netdb.h>
#include <string.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#define SERVPORT 80
#define MAXDATASIZE 100
#define TFILE "data_from_socket.txt" 

int main(int argc, char *argv[])
{
    int sockfd, recvbytes;
    char rcv_buf[MAXDATASIZE]; /*./client 127.0.0.1 hello */
    char snd_buf[MAXDATASIZE];
    struct hostent *host;             
    
    /* struct hostent
    * {
    * char *h_name; // general hostname
    * char **h_aliases; // hostname‘s alias
    * int h_addrtype; // AF_INET
    * int h_length; 
    * char **h_addr_list;
    * };
    */
    struct sockaddr_in server_addr; 

    /* */
    fd_set readset, writeset;
    int check_timeval = 1;
    struct timeval timeout={check_timeval,0}; //阻塞式select, 等待1秒，1秒轮询
    int maxfd;
    int fp;
    int cir_count = 0;
    int ret; 

    if (argc < 3)
    {
        printf("Usage:%s [ip address] [any string]\n", argv[0]);
        return 1;
    } 

    *snd_buf = ‘\0‘;
    strcat(snd_buf, argv[2]); 

    if ((fp = open(TFILE,O_WRONLY)) < 0)    //不是用fopen
    {
        perror("fopen:");
        exit(1);
    } 

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("socket:");
        exit(1);
    } 

    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(SERVPORT);
    inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
    memset(&(server_addr.sin_zero), 0, 8); 

    /* create the connection by socket 
    * means that connect "sockfd" to "server_addr"
    */
    if (connect(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr)) == -1)
    {
        perror("connect");
        exit(1);
    } 

    /**/
    if (send(sockfd, snd_buf, sizeof(snd_buf), 0) == -1)
    {
        perror("send:");
        exit(1);
    }
    printf("send:%s\n", snd_buf);
 
    while (1)
    {
        FD_ZERO(&readset);            //每次循环都要清空集合，否则不能检测描述符变化
        FD_SET(sockfd, &readset);     //添加描述符       
        FD_ZERO(&writeset);
        FD_SET(fp,     &writeset); 

        maxfd = sockfd > fp ? (sockfd+1) : (fp+1);    //描述符最大值加1 

        ret = select(maxfd, &readset, NULL, NULL, &timeout);   // 非阻塞模式
        switch( ret)
        {
            case -1:
                exit(-1);
                break;
            case 0:
                break;
            default:
                if (FD_ISSET(sockfd, &readset))  //测试sock是否可读，即是否网络上有数据
                {
                    recvbytes = recv(sockfd, rcv_buf, MAXDATASIZE, MSG_DONTWAIT);
                    rcv_buf[recvbytes] = ‘\0‘;
                    printf("recv:%s\n", rcv_buf); 

                    if (FD_ISSET(fp, &writeset))
                    {
                        write(fp, rcv_buf, strlen(rcv_buf));   // 不是用fwrite
                    }
                    goto end;
                }
        }
        timeout.tv_sec = check_timeval;    // 必须重新设置，因为超时时间到后会将其置零 

        cir_count++;
        printf("CNT : %d \n",cir_count);
    } 

    end:
    close(fp);
    close(sockfd); 

    return 0;
}

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <stdlib.h>
#define SERVPORT 80
#define BACKLOG 10 // max numbef of client connection
#define MAXDATASIZE 100 

int main(char argc, char *argv[])
{
    int sockfd, client_fd, addr_size, recvbytes;
    char rcv_buf[MAXDATASIZE], snd_buf[MAXDATASIZE];
    char* val;
    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;
    int bReuseaddr = 1; 

    char IPdotdec[20]; 

    /* create a new socket and regiter it to os .
    * SOCK_STREAM means that supply tcp service, 
    * and must connect() before data transfort.
    */
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
    {
        perror("socket:");
        exit(1);
    } 

    /* setting server‘s socket */
    server_addr.sin_family = AF_INET;         // IPv4 network protocol
    server_addr.sin_port = htons(SERVPORT);
    server_addr.sin_addr.s_addr = INADDR_ANY; // auto IP detect
    memset(&(server_addr.sin_zero),0, 8);

    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&bReuseaddr, sizeof(int));
    if (bind(sockfd, (struct sockaddr*)&server_addr, sizeof(struct sockaddr))== -1)
    {
        perror("bind:");
        exit(1);
    } 

    /* 
    * watting for connection , 
    * and server permit to recive the requestion from sockfd 
    */
    if (listen(sockfd, BACKLOG) == -1) // BACKLOG assign thd max number of connection
    {
        perror("listen:");
        exit(1);                                                                 
    }                                                                          

    while(1)                                                                   
    {                                                                          
        addr_size = sizeof(struct sockaddr_in);                                  

        /*                                                                       
        * accept the sockfd‘s connection,                                       
        * return an new socket and assign far host to client_addr               
        */                                                                      
        printf("watting for connect...\n");                                      
        if ((client_fd = accept(sockfd, (struct sockaddr *)&client_addr, &addr_size)) == -1)   
        {                                                                        
            /* Nonblocking mode */                                                 
            perror("accept:");                                                     
            continue;                                                              
        }                                                                        

        /* network-digital to ip address */                                      
        inet_ntop(AF_INET, (void*)&client_addr, IPdotdec, 16);                   
        printf("connetion from:%d : %s\n",client_addr.sin_addr, IPdotdec);       

        //if (!fork())                                                           
        {                                                                        
        /* child process handle with the client connection */                  

        /* recive the client‘s data by client_fd */                            
        if ((recvbytes = recv(client_fd, rcv_buf, MAXDATASIZE, 0)) == -1)      
        {                                                                      
            perror("recv:");                                                     
            exit(1);                                                             
        }                                                                      
        rcv_buf[recvbytes]=‘\0‘;                                               
        printf("recv:%s\n", rcv_buf);    

        *snd_buf=‘\0‘;                                                         
        strcat(snd_buf, "welcome");                                            

        sleep(3);                                                              
        /* send the message to far-hosts by client_fd */                       
        if (send(client_fd, snd_buf, strlen(snd_buf), 0) == -1)                
        {                                                                      
            perror("send:");                                                     
            exit(1);                                                             
        }                                                                      
        printf("send:%s\n", snd_buf);                                          

        close(client_fd);                                                      
        //exit(1);                                                             
        }                                                                        

        //close(client_fd);                                                      
    } 

    return 0;                                                                  
}       

1. 调用read
2. read请求会立即返回，说明请求已经成功发起了
3. 在后台完成读操作这段时间内，应用程序可以执行其他处理操作
4. 当 read 的响应到达时，就会产生一个信号或执行一个基于线程的回调函数来完成这次I/O处理过程

http://www.cnblogs.com/yjf512/archive/2012/06/05/2536005.html
http://www.cnblogs.com/yjf512/archive/2012/06/07/2539755.html
http://www.cnblogs.com/yjf512/archive/2012/06/11/2545615.html
http://blog.chinaunix.net/uid-26000296-id-4100620.html