IO复用：select函数

最新推荐文章于 2024-09-10 20:57:59 发布
最新推荐文章于 2024-09-10 20:57:59 发布
阅读量1.5k 收藏 2
点赞数 1
分类专栏： 网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ooooo12345re/article/details/51594649
版权
IO模型：
（1）阻塞式IO模型：

         最流行的I/O模型是阻塞式I/O模型，默认情况下，所有的套接字都是阻塞的。

如上图所示，进程调用recvfrom，其系统调用直到数据报到达且被复制到应用进程的缓冲区中或发生错误才返回。最常见的错误是系统调用被信号中断，我们说进程在从调用recvfrom开始到它返回的整段时间内是被阻塞的。recvfrom成功返回后，应用进程开始处理数据报。

（2）非阻塞式I/O模型：

    进程把一个套接字设置成非阻塞是在通知内核：当所请求的I/O操作非得把本进程投入睡眠才能完成时，不要把本进程投入睡眠，而是返回一个错误。

前三次调用recvfrom时没有数据可返回，因此内核转而立即返回一个EWOULDBLOCK错误。第四次调用recvfrom时已有一个数据报准备好，它被复制到应用进程缓冲区，于是recvfrom成功返回。我们接着处理数据。

   当一个应用进程像这样对一个非阻塞描述符循环调用recvfrom时，我们称之为轮询。应用进程持续轮询内核，以查看某个操作是否就绪。这么做往往耗费大量CPU时间，不过这种模型偶尔也会遇到，通常是在专门提供某一种功能的系统中才有。

（3）I/O复用模型：
     有了I/O复用。我们就可以调用select或poll，阻塞在这两个系统调用中的某一个之上，而不是阻塞在真正的I/O系统调用上。

     我们阻塞于select调用，等待数据报套接字变为可读。当select返回套接字可读这一条件时，我们调用recvfrom把所读数据报复制到应用进程缓冲区。

     比较I/O复用图和I/O阻塞图，I/O复用并不显得有什么优势，实际上由于使用select需要两个而不是单个系统调用，I/O复用还稍有优势。使用select的优势在于我们可以等待多个描述符就绪。

（4）信号驱动式I/O模型：
      我们也可以用信号，让内核在描述符就绪时发送SIGNO信号通知我们。我们称这种模型为信号驱动式I/O。

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

    无论如何处理SIGIO信号，这种模型的优势在于等待数据报到达期间进程不被阻塞。主循环可以继续执行，只要等待来自信号处理函数的通知：既可以是数据报已准备好，也可以是数据报已准备好读取。

（5）异步I/O模型：
     其工作机制是：告知内核启动某个操作，并让内核在整个操作（包括将数据从内核复制到我们自己的缓冲区）完成后通知我们。这种模型与前一个的信号驱动模型的主要区别在于：信号驱动式I/O是由内核通知我们何时可以启动一个I/O操作，而异步I/O模型是由内核通知我们I/O操作何时完成。

各I/O模型的比较：

select函数：
    该函数允许进程指示内核等待多个事件中的任何一个，并只有在一个或多个事件发生或经历一段指定的时间后才唤醒它。

    #include<sys/select.h>

    #include<sys/time.h>

    int select(int  maxfdp1，fd_set *readset，fd_set *writeset，fd_set *expectset，const struct timeval *timeout)；

         返回：若有就绪描述符则为其数目，若超时则为0，若出错则为-1.

    参数timeout：它告知内核等待所指定描述符的任何一个就绪可花多长时间。其timeval结构用于指定这段时间的秒数核微妙数。

      struct timeval

      {

               long  tv_sec;

               long  tv_usec;

      }

      这个参数有以下三种可能：
         （1）永远等待下去：仅在有一个描述符准备好I/O才返回。为此，我们把参数设置为空指针。

         （2）等待一段固定时间：在有一个描述符准备好I/O时返回，但是不超过由该参数所指向的timeval结构中指定的秒数和微妙数。

          （3）根本不等待：检查描述符后立即返回，这称为轮询。为此，该参数必须指向一个timeval结构，而且其中的定时器值必须为0。

    中间的三个参数readset、writeset和exceptset指定我们要让内核测试读、写和异常条件的描述符。select使用描述符集，通常是一个整数数组，其中每个整数中的每一位对应一个描述符。举例来说，假设使用32为整数，那么该数组的第一个元素对应于描述符0～31，第二个元素对应于描述符32～63，依次类推。这些隐藏在名为fd_set的数据类型和以下四个宏中：
     void FD_ZERO(fd_set *fdset)；

     void FD_SET(int fd，fd_set *fdset)；

     void FD_CLR(int fd，fd_set *fdset)；

     void FD_ISSET(int fd，fd_set *fdset)；

     我们分配一个fd_set数据类型的描述符集，并用这些宏设置或测试该集合中的每一位，也可以用C语言中的赋值语句把它赋值成另外一个描述符集。

     select函数的中间三个参数readset、writeset和expectset中，如果我们对某一个的条件不感兴趣，就可以把它设为空指针。

     maxfdp1参数指定待测试的描述符个数，它的值是待测试的最大描述符加1，描述符0，1，2....一直到maxfdp1 - 1均被测试。

    下面给出select的一个简单程序，该程序实现客户端给服务器发送消息，服务器将消息回射回来，解决当有多个客户端向服务器发送数据时，服务器能辨识出是与哪个客户端通信。。。

服务器：

#include"../util.h"
#include<malloc.h>

typedef struct server_context_st
{
    int cli_cnt;      //当前客户端的连接个数
    int clifds[SIZE]; //客户端连接成功套接字
    fd_set allfds;    //描述符集
    int maxfd;        //待测试的描述符个数
}server_context_st;

static server_context_st *s_srv_ctx = NULL;

//结构体的初始化
int server_init()
{
    s_srv_ctx = (server_context_st *)malloc(sizeof(server_context_st));
    if(s_srv_ctx == NULL)
        return -1;
    memset(s_srv_ctx,0,sizeof(server_context_st));
    for(int i = 0; i < SIZE; ++i)
    {
        s_srv_ctx->clifds[i] = -1;
    }
    return 0;
}
void server_uninit()
{
    if(s_srv_ctx)
    {
        free(s_srv_ctx);
        s_srv_ctx = NULL;
    }
}

int create_server_proc(const char*ip,short port)
{
    int fd;
    //创建套接字
    fd = socket(AF_INET,SOCK_STREAM,0);
    if(fd == -1)
    {
        perror("socket");
        return -1;
    }
    struct sockaddr_in addrSer;
    addrSer.sin_family = AF_INET;
    addrSer.sin_port = htons(port);
    addrSer.sin_addr.s_addr = inet_addr(ip);

    socklen_t addrlen = sizeof(struct sockaddr);
    //绑定
    int res = bind(fd,(struct sockaddr*)&addrSer,addrlen);
    if(res == -1)
    {
        perror("bind");
        return -1;
    }
    //监听
    listen(fd,LISTENQ);
    return fd;
}

int  accept_client_proc(int srvfd)
{
    struct sockaddr_in addrCli;
    socklen_t addrlen = sizeof(struct sockaddr);

    int clifd;
ACCEPT:
    clifd = accept(srvfd,(struct sockaddr *)&addrCli,&addrlen);
    if(clifd == -1)
    {
       goto ACCEPT;
    }

    printf("accept a new client: %s:%d\n",inet_ntoa(addrCli.sin_addr),addrCli.sin_port);

    int i;
    //在数组中遍历描述符为-1的项
    for(i = 0; i < SIZE; ++i)
    {
        if(s_srv_ctx->clifds[i] == -1)
        {
            s_srv_ctx->clifds[i] = clifd;
            //修改客户端连接个数
            s_srv_ctx->cli_cnt++;
            break;
        }
    }
    if(i == SIZE)
    {
        printf("server over load.\n");
        return -1;
    }
}

void handle_client_msg(int fd,char* buf)
{
    //将接收到的数据又发送到客户端
    printf("recv buf is:>%s\n",buf);
    send(fd,buf,strlen(buf)+1,0);
}
void recv_client_msg(fd_set *readfds)
{
    int clifd;
    char buffer[256];
    int n;
    for(int i = 0; i < s_srv_ctx->cli_cnt;++i)
    {
        clifd = s_srv_ctx->clifds[i];
        if(clifd < 0)
            continue;
        if(FD_ISSET(clifd,readfds))
        {
            n = recv(clifd,buffer,256,0);
            //n小于0时说明客户端断开连接
            if(n <= 0)
            {
                FD_CLR(clifd,&s_srv_ctx->allfds);
                close(clifd);
                s_srv_ctx->clifds[i] = -1;
                s_srv_ctx->cli_cnt--;
                continue;
            }
            //处理来自客户端的数据
            handle_client_msg(clifd,buffer);
        }
    }
}
int handle_client_proc(int srvfd)
{
    int clifd = -1;
    int retval = 0;
    fd_set *readfds = &s_srv_ctx->allfds;
    struct timeval tv;

    while(1)
    {
        //清空描述符集合
        FD_ZERO(readfds);
        //置位
        FD_SET(srvfd,readfds);
        s_srv_ctx->maxfd = srvfd;
        tv.tv_sec = 30;
        tv.tv_usec = 0;

        int i;
        for(i = 0; i < s_srv_ctx->cli_cnt; ++i)
        {
            clifd = s_srv_ctx->clifds[i];
            //将连接成功的客户端在集合内置位
            FD_SET(clifd,readfds);
            s_srv_ctx->maxfd = (clifd > s_srv_ctx->maxfd ? clifd : s_srv_ctx->maxfd);
        }
        
        retval = select(s_srv_ctx->maxfd+1,readfds,NULL,NULL,&tv);
        if(retval == -1)
        {
            perror("select");
            return -1;
        }
        if(retval == 0)
        {
            perror("select time out.\n");
            continue;
        }

        //accept
        if(FD_ISSET(srvfd,readfds))
        {
            //接受新的客户端的连接
            accept_client_proc(srvfd);
        }
        else
        {
            //接收已连接客户端的数据
            recv_client_msg(readfds);
        }
    }
}
int main(int argc,char*argv[])
{
    int sockSer;
    if(server_init() < 0)
        perror("server_init");
    sockSer = create_server_proc(IPADDR,PORT);
    if(sockSer < 0)
    {
        perror("create_server_porc");
        goto err;
    }
    handle_client_proc(sockSer);
    return 0;
err:
    server_uninit();
    return -1;
}

客户端： 
#include"../util.h"

void handle_connection(int sockfd)
{
    fd_set readfds;
    int maxfd = sockfd;
    struct timeval tv;

    while(1)
    {
        //将描述符集合清空
        FD_ZERO(&readfds);
        FD_SET(sockfd,&readfds);
        maxfd = sockfd;
        tv.tv_sec = 5;
        tv.tv_usec = 0;

        int res = select(maxfd + 1,&readfds,NULL,NULL,&tv);
        if(res == -1)
        {
            perror("select");
            return;
        }
        if(res == 0)
        {
            printf("client time out.\n");
            continue;
        }
        int n;
        char recvbuf[256];
        if(FD_ISSET(sockfd,&readfds))
        {
            n = recv(sockfd,recvbuf,256,0);
            //n小于0说明服务器关闭
            if(n <= 0)
            {
                printf("server is closed.\n");
                close(sockfd);
                FD_CLR(sockfd,&readfds);
                return ;
            }
            printf("client recv self msg:>%s\n",recvbuf);
            //sleep(3);
            char sendbuf[256];
            scanf("%s",sendbuf);
            send(sockfd,sendbuf,strlen(sendbuf)+1,0);
        }
    }
}

int main(int argc,char*argv[])
{
    int sockCli;
    //创建套接字
    sockCli = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in addrSer;
    addrSer.sin_family = AF_INET;
    addrSer.sin_port = htons(PORT);
    addrSer.sin_addr.s_addr = inet_addr(IPADDR);

    socklen_t addrlen = sizeof(struct sockaddr);
    //连接服务器
    int res = connect(sockCli,(struct sockaddr *)&addrSer,addrlen);
    if(res < 0)
        perror("connect");
    printf("client connect server ok.\n");
    //发送数据
    char sendbuf[256];
    scanf("%s",sendbuf);
    send(sockCli,sendbuf,strlen(sendbuf)+1,0);
    handle_connection(sockCli);

    return 0;
}

公用头文件： 

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<poll.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/socket.h>
#include<string.h>

#define IPADDR "127.0.0.1"
#define PORT 8787
#define MAXLINE 1024
#define LISTENQ 5

#define SIZE 10
#define OPEN_SIZE 5

程序的执行结果：

程序的执行结果如图所示。。。

fantasy_linux
关注
专栏目录
IO多路复用之select函数详解
lixungogogo的博客
08-17 1万+
IO复用 　　我们首先来看看服务器编程的模型，客户端发来的请求服务端会产生一个进程来对其进行服务，每当来一个客户请求就产生一个进程来服务，然而进程不可能无限制的产生，因此为了解决大量客户端访问的问题，引入了IO复用技术。 　　即：一个进程可以同时对多个客户请求进行服务。 　　也就是说IO复用的“介质”是进程(准确的说复用的是select和poll，因为进程也是靠调用select和poll来实
IO复用之select函数介绍
子居的博客
07-17 568
文章目录函数说明函数原型：函数功能：参数说明：函数原理编程实现总结描述符就绪条件(拓展) 函数说明 函数原型： /* According to POSIX.1-2001, POSIX.1-2008 */ #include <sys/select.h> /* According to earlier standards */ #include <sys/time.h> #include <sys/types.h> #include <unistd.h> in
select函数详解：IO复用
最新发布
m0_58572142的博客
09-10 1177
select函数是一种用于实现I/O复用的方法，它可以让程序在多个文件描述符（例如套接字）之间进行选择，以便在其中任何一个或多个可用时执行I/O操作。这种机制使得程序能够更高效地处理多个I/O操作。下面将对select的原理和工作机制进行详细介绍，并分析select函数的优势和局限。
IO复用之select
qq_44272681的博客
08-21 194
这个函数允许进程指示内核等待多个事件中的任意一个发生，并仅在一个或多个事件发生或超时后才唤醒进程。相比于普通的阻塞IO模型，select把多个要处理的文件描述符纳入自己的监管，在设定的时间内阻塞查询，看哪些套接字是就绪的。如果是就绪的则对这些套接字进行IO处理 一、select函数的调用过程 步骤1： 1.设置文件描述符 2.指定监视范围 3.设置超时 步骤2： 调用select函数 步骤3： 查看调用结果 二、函数接口 1.fd_set fd_set是一种数组类型,其中的数组元素
Linux中select IO复用机制
ZHCX2011的专栏
06-17 821
函数作用： 系统提供select函数来实现多路复用输入/输出模型。select系统调用是用来让我们的程序监视多个文件句柄的状态变化的。程序会停在select这里等待，直到被监视的文件句柄有一个或多个发生了状态改变。关于文件句柄，其实就是一个整数，我们最熟悉的句柄是0、1、2三个，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE *结构的表示就是stdin、
IO复用:select,poll,epoll,kqueue的详细例子
04-30
本文将深入探讨四种常见的IO复用机制：`select`、`poll`、`epoll`和`kqueue`，并结合源码分析如何在实际项目中应用它们。我们将通过分析`service.cpp`（服务端）和`client.cpp`（客户端）来理解这些机制的工作原理。...
Linux IO复用：select、poll、epoll深度解析
1. select函数 - `select`函数的核心参数是`nfds`，它表示`fd_set`集合中最大描述符值加1。`fd_set`是一个位数组，通常在32位系统中大小为1024，意味着最多可以监控1024个文件描述符。 - `readfds`、`writefds`和`...
Linux IO复用：select、poll与epoll全面对比分析
select函数的原型如上所述，它的第一个参数nfds是文件描述符集中的最大描述符值加1。fd_set是一个位数组，用于存储文件描述符的状态，其大小有限制，默认为1024。这意味着select无法处理超过1024个文件描述符。函数...
IO多路复用深入解析：select函数全面剖析
如果timeout为NULL，则select函数会一直阻塞，直到有文件描述符就绪才会返回。 3、select的工作原理 select的工作方式是通过内核维护一个描述符集，当调用select时，内核会检查所有指定的描述符，看哪些已经准备好...
Linux网络编程 | IO复用 : select系统调用详解（实现改进的多客户/服务器）
ZY-JIMMY
04-18 1944
select API 、文件描述符就绪条件 、读取键盘(标准输入) 、改进的多客户/服务器
IO多路复用
热门推荐
chewbee的专栏
09-26 1万+
I/O多路复用机制 IO多路复用机制 简介 1流的概念 2 IO同步异步阻塞非阻塞 3 多路复用概念 4 IO复用的优势 IO复用函数介绍 1 select函数 2 Poll函数 3epoll函数 4 epoll相比于selectpoll的优势 总结 1.简介希望通过这篇文章，可以回答以下几个问题？ 为什么需要IO多路复用？ 什么是IO多路复用机制？ IO多路复用的机制该怎么使用？ epoll比se
I/O复用之Select
ThorKing01的博客
08-05 211
select主要通过维护一个套接字队列，来完成单线程的IO复用，利用以下几个函数实现 NAME select, pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO - synchronous I/O multiplexing 函数声明 SYNOPSIS /* According to POSIX.1-2001 */ #include <sys/select.h> /* Accor
select函数_你知道什么是Select函数吗？
weixin_39949673的博客
12-06 264
Select函数：允许进程指示内核等待多个事件中的任何一个发生，并只在有一个或多个事件发生或经历一段指定的时间后才唤醒它。select man手册举个栗子，我们可以调用Select，告诉内核仅仅在下列情况发生时才返回：集合{1,4,5}中任何描述符准备好读集合{2,7}中任何描述符准备好写集合{1,4}中任何描述符由异常条件待处理已经经历了10秒我们调用Select告诉内核对哪些描述符感兴趣以及等...
IO复用，select，
weixin_45510561的博客
04-05 731
一，IO复用的方法 IO复用的方法：select poll epoll IO复用的功能 这里的描述符就是套接字 以前TCP服务器端和客户端 一个服务器端要连接10个客户端就需要创建10个线程 学校发书，所有人在图书馆排队领书没到你你就在等相当于阻塞，另一种到你了我给你打电话你再来领就不会出现阻塞（例子） 在程序中来讲就是我们将所有要关注的描述符全部注册到select上，select帮我们检测哪个描述符上有数据产生（有可能是一个或2,3个上同时有数据） 举个例子来使用select 检测键盘（键盘也是描述符）
IO复用--select
u013827488的博客
05-03 159
API fd_set * rset; FD_ZERO(&rset); FD_SET(int fd, &rset); FD_ISSET(fd, &rset); FD_CRL(int fd, &rset); int select(maxfd+1, fd_set * rfd, fd_set * wfd, fd_set * excepfd, struct timeval...
I/O 复用之select 函数
aisxyz
12-12 154
select 函数允许进程指示内核等待多个事件中的任何一个发生，并只在有一个或多个事件发生或经历一段指定的时间后才唤醒它。感兴趣的描述符不局限于套接字，任何描述符都可以使用 select 来测试。 [code="c"] #include #include int select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_...
select函数
寂蝶难双，窃窃思羽.
05-07 1186
转载自：https://blog.csdn.net/silent123go/article/details/52577160 一、函数原型及参数说明 int select(int maxfdp, fd_set *readfds, fd_set *writefds, fd_set *errorfds, struct timeval *timeout); 返回值： 负值：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值