【网络】（七）五种I/O模型--I/O复用 Select（一）

最新推荐文章于 2019-04-24 15:48:23 发布
最新推荐文章于 2019-04-24 15:48:23 发布
阅读量907 收藏
点赞数
分类专栏： Linux 编程 文章标签： io 网络 异步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cmbug/article/details/48419983
版权

1、五种I/O模型

五种I/O模型分别是：

  • 阻塞I/O
  • 非阻塞I/O
  • I/O复用（select/poll）
  • 信号驱动I/O
  • 异步I/O

0.1 阻塞I/O

这里写图片描述

连接完成，我们通常使用recv函数读取数据，如果此时没有数据，那么该函数阻塞，直到对方发送的数据到达套接口缓冲区，此时该函数将数据复制到用户缓冲区中，并返回！

0.2 非阻塞I/O

这里写图片描述

连接完成，调用recv函数，并将套接口设置为非阻塞模式(fcntl(sk_fd,F_SETFL,flag|O_NONBLOCK));此时，即使没有数据到来，该函数也不会阻塞，它会返回一个错误-1，errno为EWOULDBLOCK，此时需要再次提交请求，一直这样循环，直到有数据到来，才复制数据到用户缓冲区！很少使用这种方式！

0.3 I/O 复用

这里写图片描述

连接完成后，使用select来管理所有的I/O，一旦其中的一个IO或这多个IO发生了我们感兴趣的事件，select函数就返回，返回值为检测到的个数，并且会告诉我们哪些IO发生了事件，事件发生后我们再调用recv去复制数据到用户缓冲区，就不会发生阻塞的情况！这种方法经常使用！

0.4 信号驱动I/O

这里写图片描述

在程序中建立一个处理SIGIO的处理程序，捕获该信号；程序可继续处理其他事情，一旦有数据到来，会以信号的方式通知程序，然后应用程序就跳转到信号处理程序中，通过recv函数复制数据到用户缓冲区！这种方式也较少使用！

0.5 异步I/O

这里写图片描述

这种方式效率是比较高的，它通过aio_read函数来实现，调用该函数，它会递交一个用户缓冲区给操作系统，就算没有数据，也立即返回，一旦有数据到来，操作系统内核会自动将数据拷贝到用户缓冲区中，然后通过一个信号通知应用程序。这种方式相当于内核在自动“推送”数据！

2、使用I/O 复用–select

select函数使用示例

客户端程序
client.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <string.h>
#include <sys/select.h>



#define handle_error(msg)   \
                    do{perror(msg);exit(EXIT_FAILURE);}while(0)

ssize_t readn(int fd, void *buf, size_t count)
{
  if((fd < 0) || (buf == NULL) || (count < 0))
        return -1;
  size_t nleft = count;   //剩余字节数
  ssize_t nread = 0;      //已读字节数
  char *pbuf = (char*)buf;
  while(nleft > 0)
  {
    if((nread = read(fd, pbuf, nleft)) < 0)
    {
        if(errno == EINTR)
            continue;
        return -1;
    }
    else if (nread == 0)
        return count - nleft;
    pbuf += nread;
    nleft -= nread;
  }
  return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
    if((fd < 0) || (buf == NULL) || (count < 0))
          return -1;
    size_t nleft = count;   //剩余字节数
    ssize_t nwritten = 0;      //已发送字节数
    char *pbuf = (char*)buf;
    while (nleft > 0)
    {
        if((nwritten = write(fd, pbuf, nleft)) < 0)
        {
            if(errno == EINTR)
                continue;
            return -1;
        }
        else if(nwritten == 0)
            continue;
        pbuf += nwritten;
        nleft -= nwritten;
    }
    return count;
}

//使用recv函数从套接字接收缓冲区中接收数据，但并不从缓冲去中清除数据
ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while(true)
    {
        int iret = recv(sockfd, buf, len, MSG_PEEK);
        if(iret == -1 && errno == EINTR)    //如果失败是因为信号中端，那么就重新再试
            continue;
        return iret;
    }
}



ssize_t recvline(int sockfd, void *buf, size_t maxlen)
{
    int iret = 0;
    int nread = 0;  //已读数据
    char *pbuf = (char*)buf;
    int nleft = maxlen; //剩余字符
    while(true)
    {
        iret = recv_peek(sockfd, pbuf, nleft);
        if(iret < 0)
            return iret;    //读取失败
        else if(iret == 0)
            return iret;    //对方关闭套接口

        nread = iret;
        if(nread > nleft)       //已经读取到的数据只可能小于或者等于剩余的数据
            exit(EXIT_FAILURE);

        for(int i = 0; i < nread; i++)
        {
            if(pbuf[i] == '\n')
            {
                iret = readn(sockfd, pbuf, i+1);    //从缓冲区中读走包括\n在内的数据
                if(iret != i+1)
                    exit(EXIT_FAILURE);     //没有读取都i+1个数据，说明失败
                return iret;                //读取都\n返回
            }
        }

        //在当前读到的数据中没有发现\n,那么先将这部分数据从缓冲区中读走，然后接着偷窥后面的数据
        nleft -= nread;
        iret = readn(sockfd, pbuf, nread);
        if(iret != nread)
            exit(EXIT_FAILURE);
        pbuf += nread;
    }
    return -1;
}

//select可看做一个管理者，可用它来管理多个IO，
//一旦其中的一个IO或这多个IO发生了我们感兴趣的事件，select函数就返回，
//返回值为检测到的个数，并且会告诉我们哪些IO发生了事件

//参数：
    //1、读写异常集合中的文件描述父的最大值+1
    //读集合，输入输出参数
    //写集合，输入输出参数
    //异常集合，输入输出参数
    //超时结构体，设置此结构体后，可设定让select函数返回的超时时间
void client_handler(int sk_fd)
{
    fd_set readset;
    FD_ZERO(&readset);
    int nready = 0;
    int fd_stdin = fileno(stdin);   //获得标准输入的描述符，防止输入重定向
    int fd_max = fd_stdin > sk_fd ? fd_stdin : sk_fd;
    while(true)
    {
        FD_SET(fd_stdin, &readset);
        FD_SET(sk_fd, &readset);        //readset集合可能会改变，所以每次都要添加
        nready = select(fd_max + 1, &readset, NULL, NULL, NULL);
        if(nready == -1)
            handle_error("select");
        if(nready == 0)
            continue;
        if(FD_ISSET(sk_fd, &readset))   //套接口产生了读事件
        {
            char recvbuf[1024] = {0};
            int iret = recvline(sk_fd, recvbuf, sizeof(recvbuf)); //接收包数据长度
            if(iret == -1)
                handle_error("read");
            else if(iret == 0)
            {
                printf("Server was closed!\n");
                break;
            }
            fputs(recvbuf, stdout);
            memset(&recvbuf, 0, sizeof(recvbuf));
        }
        if(FD_ISSET(fd_stdin, &readset))    //标准输入产生读事件
        {
            char sendbuf[1024] = {0};
            if(fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)
                break;
            writen(sk_fd, sendbuf, strlen(sendbuf));   //发送数据
            memset(&sendbuf, 0, sizeof(sendbuf));
        }
    }
}



int main(void)
{
    int sk_fd;
    sk_fd = socket(AF_INET, SOCK_STREAM , IPPROTO_TCP);
    if(sk_fd < 0)
        handle_error("socket");
    struct sockaddr_in sr_addr;
    memset(&sr_addr,0,sizeof(sr_addr));
    sr_addr.sin_family = AF_INET;
    sr_addr.sin_port = htons(5188);
    //sr_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    sr_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    //inet_aton("127.0.0.1",&sr_addr.sin_addr);

    if(connect(sk_fd, (struct sockaddr*)&sr_addr, sizeof(sr_addr)) < 0)
    {
        close(sk_fd);
        handle_error("connect");
    }

    client_handler(sk_fd);
    close(sk_fd);
    return 0;
}

服务端程序
server.c

编译命令：gcc -Wall -g -std=gnu99 server.c -o server

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <sys/wait.h>


#define handle_error(msg)   \
                    do{perror(msg);exit(EXIT_FAILURE);}while(0)

//忽略子进程的SIG_CHLD信号
void handle_SIGIGN(void)
{
  struct sigaction act_chld;
  act_chld.sa_handler = SIG_IGN;
  act_chld.sa_flags = 0;
  sigemptyset(&act_chld.sa_mask);

  if(-1 == sigaction(SIGCHLD, &act_chld, NULL))//捕获终端中断信号
      handle_error("sigaction SIGCHLD");
}

void wait_sigchld(int sig)
{
    wait(NULL);
}
//调用wait函数处理该信号
void handle_wait(void)
{
  struct sigaction act_chld;
  act_chld.sa_handler = wait_sigchld;
  act_chld.sa_flags = 0;
  sigemptyset(&act_chld.sa_mask);

  if(-1 == sigaction(SIGCHLD, &act_chld, NULL))//捕获终端中断信号
      handle_error("sigaction SIGCHLD");
}

void waitpid_sigchld(int sig)
{
    while( waitpid(-1,NULL,WNOHANG) >= 0); //不将执行挂起
}
//调用wait函数处理该信号
void handle_waitpid(void)
{
  struct sigaction act_chld;
  act_chld.sa_handler = waitpid_sigchld;
  act_chld.sa_flags = 0;
  sigemptyset(&act_chld.sa_mask);

  if(-1 == sigaction(SIGCHLD, &act_chld, NULL))//捕获终端中断信号
      handle_error("sigaction SIGCHLD");
}

ssize_t readn(int fd, void *buf, size_t count)
{
  if((fd < 0) || (buf == NULL) || (count < 0))
        return -1;
  size_t nleft = count;   //剩余字节数
  ssize_t nread = 0;      //已读字节数
  char *pbuf = (char*)buf;
  while(nleft > 0)
  {
    if((nread = read(fd, pbuf, nleft)) < 0)
    {
        if(errno == EINTR)
            continue;
        return -1;
    }
    else if (nread == 0)
        return count - nleft;
    pbuf += nread;
    nleft -= nread;
  }
  return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
    if((fd < 0) || (buf == NULL) || (count < 0))
          return -1;
    size_t nleft = count;   //剩余字节数
    ssize_t nwritten = 0;      //已发送字节数
    char *pbuf = (char*)buf;
    while (nleft > 0)
    {
        if((nwritten = write(fd, pbuf, nleft)) < 0)
        {
            if(errno == EINTR)
                continue;
            return -1;
        }
        else if(nwritten == 0)
            continue;
        pbuf += nwritten;
        nleft -= nwritten;
    }
    return count;
}

//使用recv函数从套接字接收缓冲区中接收数据，但并不从缓冲去中清除数据
ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while(true)
    {
        int iret = recv(sockfd, buf, len, MSG_PEEK);
        if(iret == -1 && errno == EINTR)    //如果失败是因为信号中端，那么就重新再试
            continue;
        return iret;
    }
}

//如果读到的数据包含\n，则返回，表示一条完整的消息读取完毕
ssize_t recvline(int sockfd, void *buf, size_t maxlen)
{
    int iret = 0;
    int nread = 0;  //已读数据
    char *pbuf = (char*)buf;
    int nleft = maxlen; //剩余字符
    while(true)
    {
        iret = recv_peek(sockfd, pbuf, nleft);
        if(iret < 0)
            return iret;    //读取失败
        else if(iret == 0)
            return iret;    //对方关闭套接口

        nread = iret;
        if(nread > nleft)       //已经读取到的数据只可能小于或者等于剩余的数据
            exit(EXIT_FAILURE);

        for(int i = 0; i < nread; i++)
        {
            if(pbuf[i] == '\n')
            {
                iret = readn(sockfd, pbuf, i+1);    //从缓冲区中读走包括\n在内的数据
                if(iret != i+1)
                    exit(EXIT_FAILURE);     //没有读取都i+1个数据，说明失败
                return iret;                //读取都\n返回
            }
        }

        //在当前读到的数据中没有发现\n,那么先将这部分数据从缓冲区中读走，然后接着偷窥后面的数据
        nleft -= nread;
        iret = readn(sockfd, pbuf, nread);
        if(iret != nread)
            exit(EXIT_FAILURE);
        pbuf += nread;
    }
    return -1;
}


void do_work(int sock);


int main(void)
{
    //三种僵尸进程处理方式
    //handle_SIGIGN();
    //handle_wait();
    handle_waitpid();


    int sk_fd = socket(AF_INET, SOCK_STREAM , IPPROTO_TCP);
    if(sk_fd < 0)
        handle_error("socket");


    //使用REUSEADDR，不必等待TIME_WAIT 状态消失，就可以重新使用端口
    int on = 1;
    if(setsockopt(sk_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
    {
        close(sk_fd);
        handle_error("setsockopt");
    }


    struct sockaddr_in sr_addr;
    memset(&sr_addr,0,sizeof(sr_addr));
    sr_addr.sin_family = AF_INET;
    sr_addr.sin_port = htons(5188);
    sr_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    //sr_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    //inet_aton("127.0.0.1",&sr_addr.sin_addr);

    if(bind(sk_fd, (struct sockaddr*)&sr_addr, sizeof(sr_addr)) < 0)
    {
        close(sk_fd);
        handle_error("bind");
    }

    //被动套接字
    if(listen(sk_fd, SOMAXCONN) < 0)     //内核为此套接字排队的最大连接数由SOMAXCONN宏指定
    {
        close(sk_fd);
        handle_error("listen");
    }


    struct sockaddr_in cl_addr;
    socklen_t cl_length = sizeof(cl_addr);
    pid_t pid;
    while (true)
    {
        memset(&cl_addr,0,sizeof(cl_addr));
        int ac_sk = accept(sk_fd, (struct sockaddr *)&cl_addr, &cl_length);
        if(ac_sk < 0)
        {
            if(errno == EINTR)
                continue;
            close(sk_fd);
            handle_error("accept");
        }
        printf("Connect ip = %s\tport = %d\n",inet_ntoa(cl_addr.sin_addr),ntohs(cl_addr.sin_port));

        //每个客户端对应一个子进程
        pid = fork();
        if(pid == -1)
            handle_error("fork");
        if(pid == 0)
        {
            close(sk_fd);
            do_work(ac_sk);
            close(ac_sk);
            exit(EXIT_SUCCESS);
        }
        else
            close(ac_sk);
    }
    close(sk_fd);
    return 0;
}


void do_work(int sock)
{
    char recvbuf[1024];
    while(true)
    {
        memset(recvbuf,0,sizeof(recvbuf));
        int iret = recvline(sock,recvbuf,sizeof(recvbuf));    //获取包数据长度
        if(iret == -1)
            handle_error("read");
        else if(iret == 0)
        {
            printf("Client was closed!\n");
            break;
        }
        fputs(recvbuf,stdout);
        writen(sock, recvbuf, strlen(recvbuf));    //回传数据
    }
}
CMbug
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
I/O复用---select函数实现并发服务器
amoscykl的博客
05-12 2349
基于I/O复用的服务器端 复用技术在服务器端的应用 多进程服务器端模型：(一个进程对应一个客户端)                                                                             在模型中引入复用技术，减少进程数。无论连接多少客户端，提供服务的进程只有1个。                                   ...
获取进程能打开的最大文件数量【OPEN_MAX】
CMbug的专栏
09-09 7745
手上一个小项目，需要获取一个当前Linux操作系统下，一个进程能打开的最大文件数目，在《linux程序设计 第4版》 85页有说：  任何一个运行中的程序能够同时打开的文件数是有限制的，这个限制通常是由limits.h头文件中的常量OPEN_MAX定义的，它的值随系统的不同而不同，但POSIX要求它至少为16！  但我尝试使用该宏时，却已经找不到该宏的定义了，查了一下资料，才知道2.6.24以后的内
Linux的三种I/O复用方式——select
Kevinonlie的博客
04-24 495
I/O复用函数 select poll epoll<Linux的独有的I/O复用> 接下来我们逐一进行介绍//这里插入I/O复用的功能 select select的原型是 int select(int maxfd,fd_set *readfds,fd_set,fd_set *writefds,fd_set *exceptfds,struct timeval *timeout); ma...
Linux的socket编程详解
panrenqiu的博客
04-24 216
Linux的SOCKET编程详解 原作者：https://www.cnblogs.com/jiangzhaowei/p/8261174.html 1. 网络中进程之间如何通信进 程通信的概念最初来源于单机系统。由于每个进程都在自己的地址范围内运行，为保证两个相互通信的进程之间既互不干扰又协调一致工作，操作系统为进程通信提供了相应设施，如UNIX BSD有：管道（pipe）、命名管道（named p...
ip地址与整数相互转换
marho
07-06 2万+
1、ip地址转成整数 原理：ip地址的每段可以看成是一个0-255的整数，把每段拆分成一个二进制形式组合起来，然后把这个二进制数转变成整数。 举例：一个ip地址为10.0.3.193 每段数字             相对应的二进制数 10                   00001010 0                    00000000 3
127.0.0.1和0.0.0.0地址的区别
热门推荐
Amos.zheng's Blog
02-14 6万+
1. IP地址分类 1.1 IP地址表示 IP地址由两个部分组成，net-id和host-id，即网络号和主机号。  net-id:表示ip地址所在的网络号。  host-id：表示ip地址所在网络中的某个主机号码。  即：   IP-address ::= { , } 1.2 IP地址分类 IP地址一共分为5类，即A～E，它们分类的依据是其net-id所占的
利用I/O复用模型实现一个时间同步服务器
01-19
服务端采用I/O复用模型（select函数）接收客户端的时间同步请求 服务端采用单线程，但要能同时接收多客户端的连接请 求，显示客户端IP和端口，并向其回送时间信息。 客户端尝试同时使用 UDP 和 TCP 来实现。 注：...
c++实现win socket 编程中的Select I/O模型
01-28
采用C++语言实现，在VS2010下开发，代码中有相关的注释，如发现问题请不吝指教，谢谢
总结网络IO模型与select模型的Python实例讲解
12-24
网络I/O模型 人多了，就会有问题。web刚出现的时候，光顾的人很少。近年来网络应用规模逐渐扩大，应用的架构也需要随之改变。C10k的问题，让工程师们需要思考服务的性能与应用的并发能力。 网络应用需要处理的无非...
socket网络编程-epoll-水平触发和边缘触发源码
最新发布
07-22
（2）epoll技术的性能，可以说非常惊艳，它是能够使单台计算机支撑数百万甚至数十万上百万并发的核心技术，远优于其他I/O模型或I/O函数（如select、poll函数），select和poll这类技术因为系统内部实现问题，当并发...
关于Redis网络模型的源码详析
12-14
Redis的网络模型是基于I/O多路复用程序来实现的。源码中包含四种多路复用函数库epoll、select、evport、kqueue。在程序编译时会根据系统自动选择这四种库其中之一。下面以epoll为例，来分析Redis的I/O模块的源码。 ...
Windows WCHAR 到 Linux wchar_t 字符类型的转换
CMbug的专栏
05-14 4386
1、简介 这几天涉及到一个小项目，Windows 和Linux通过TCP进行通信，但是他们之间的字符类型上是有区别的，所有Windows上的数据发送到Linux上后，如果不经过转换，会出现乱码的情况，Windows 的WCHAR类型实际上是wchar_t，但是它只占用2个字节（既UTF-16），而Linux上wchar_t则使用的是多字节（UTF-8），下面的函数提供了他们之间的相互转换！2、程序
【网络】（六）TCP的十一种状态
CMbug的专栏
09-13 3646
1、TCP 十种状态过程描述： 0.1 服务器B和客户端A中的套接字都处于CLOSE状态（图中未标出） 0.2 服务器B调用socket/bind/listen函数创建了一个套接字后，处于LISTEN状态，该套接字属于被动套接字，被动套接字不能用来发起连接，只能接受连接 0.3 客户端A调用socket/connect函数创建一个套接字后，处于SYN_SENT状态，该套接字属于主动套接字，用来发起连
Linux/Windows 下字符编码转换
CMbug的专栏
05-14 3037
1、简介 最近的一个小项目，涉及到字符编码的转换问题，比如Windows下的多字节编码数据到Linux下后会是乱码，因为Windows下多字节编码使用的是GB2312，而Linux下默认则使用的UTF-8，下面的类就提供了该转换的实现！2、使用简介 2.1 我如何知道该类能实现哪些编码之间的转换？ 因为在Linux上用到了iconv，所以要想知道该类支持哪些编码之间的转换，可以在终端中
【网络】（十）select的限制与解决方法poll
CMbug的专栏
09-15 1055
在前面的《第七篇》和《第八篇》文章中已经使用select函数对服务器和客户端进行了重写，但这有个问题存在，如果有非常多的客户端需要连接到服务器，那很可能连接到1020个客户端时，服务端就会报错了，原因在于用select实现的并发服务器能够达到的并发数，受两方面限制 一个进程能打开的最大文件描述符限制，这可通过调整内核参数修改！ select中的fd_set集合容量的限制（FD_SETSIZE）,它不
【网络】（五）避免僵尸进程
CMbug的专栏
09-13 864
前面的四篇文章中，对于僵尸进程都只做了简单的处理，我忽略了子进程退出时发送给父进程的SIGCHLD信号，本篇文章来详细谈论一下僵尸进程！1、为什么会有僵尸进程？当父进程fork出的子进程运行结束后，为了父进程还能够获得子进程的一些信息，系统会维护子进程的一些信息，这些信息包括子进程的进程ID、终止状态以及资源利用信息(CPU时间，内存使用量等等)。如果一个进程终止，而该进程有子进程处于僵尸状态，那么
【网络】（十一）更高效的epoll
CMbug的专栏
09-15 858
第十篇文章中将select函数换做了poll，解决了客户端最大并发数量限制的问题，
1.简单说明I/O复用技术为什么能做到支持高并发请求？
05-12
I/O复用技术可以通过一个进程或线程同时处理多个I/O请求，避免了传统的一对一阻塞式I/O模型中，每个请求都需要创建一个新的线程或进程进行处理，导致系统资源的浪费和性能瓶颈。通过I/O复用技术，可以将多个I/O请求...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值