多路复用之select

其他 2020-03-15 13:09:46 阅读次数: 0

文章目录

select（）介绍

#include <sys/select.h>
#include <sys/time.h>

int select(int max_fd, fd_set  *readset, fd_set  *writeset, fd_set  *exceptset, struct timeval  *timeout);

struct timeval 
{    long tv_sec;   //seconds  
     long tv_usec;  //microseconds
};


//下面这几个宏用来操作fd_set
FD_ZERO(fd_set* fds)         //清空集合 
FD_SET(int fd,  fd_set* fds)    //将给定的描述符加入集合 
FD_ISSET(int fd,  fd_set* fds)  //判断指定描述符是否在集合中 
FD_CLR(int fd,  fd_set* fds)    //将给定的描述符从文件中删除
  • 说明

select监视并等待多个文件描述符的属性发生变化，它监视的属性分3类，分别是readfds(文件描述符有数据到来可读)、 writefds(文件描述符可写)、和exceptfds(文件描述符异常)。调用后select函数会阻塞，直到有描述符就绪（有数据可读、可写、 或者有错误异常），或者超时（ timeout 指定等待时间）发生函数才返回。当select()函数返回后，可以通过遍历 fdset，来找到 究竟是哪些文件描述符就绪。

  1. 返回值：select函数的返回值是就绪描述符的数目，超时时返回0，出错返回-1；
  2. 第一个参数max_fd ：指待测试的fd的总个数，它的值是待测试的最大文件描述符加1。
  • Linux内核从0开始到max_fd-1扫描文件描述符，如果有数据出现事件(读、写、异常)将会返回；
  1. 中间三个参数readset、writeset和exceptset： 指定要让内核测试读、写和异常条件的fd集合，如果不需要测试的可以设置为 NULL；
  2. 最后一个参数： 设置select的超时时间，如果设置为NULL则永不超时；，这个参数至关重要，它可以使select处于三种状态，第一，若将NULL以形参传入，即不传入时间结构，就是将select置于阻塞状态，一定等到监视文件描述符集合中某个文件描述符发生变化为止；第二，若将时间值设为0秒0毫秒，就变成一个纯粹的非阻塞函数，不管文件描述符是否有变化，都立刻返回继续执行，文件无变化返回0，有变化返回一个正值；第三，timeout的值大于0，这就是等待的超时时间，即select在timeout时间内阻塞，超时时间之内有事件到来就返回了，否则在超时后不管怎样一定返回，返回值同上述。
  • 关键： 深入的理解select模型的关键点在于理解fd_set，为了说明方便，我们取fd_set长度为1个字节，fd_set中的每一个bit可以对应一个文件描述符fd。则1字节长的fd_set最大可以对应8个fd。
    （1）执行fd_set set ；FD_ZERO(&set)；则set用位表示为 0000 0000 。
    （2）若fd = 5 ，则执行 FD_SET(fd,&set)后，set变为 0001 0000 （第5位置变1）
    （3）若再加入fd=2 ，fd=1，则set变为 0001 0011
    （4）执行select(6,&set,0,0,0)阻塞等待
    （5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000 0011。没有可读事件发生时 fd = 5 被清空。
  • 优点：
    单进程执行可以为多个客户端服务，这样可以减少创建线程或进程所需要的CPU时间片或内存 资源的开销；此外几乎所有的平台上都支持select()，其良好跨平台支持是它的另一个优点
  • 缺点：
  1. 每次调用 select()都需要把fd集合从用户态拷贝到内核态，之后内核需要遍历所有传递进来的fd，这时如果客户端fd很多时会导致系统开销很大；
  2. 单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，可以通过setrlimit()、修改宏定义甚至重 新编译内核等方式来提升这一限制，但是这样也会造成效率的降低；

服务端使用select实现高并发代码

  • 下面给出一个用来处理将收到小写字母的信息转变成大写字母的客户端程序

伪代码

static  inline  void    msleep(unsigned long ms);  //延时函数的申明
static  inline  void    print_usage(char *progname);  //打印帮助信息函数申明
int     socket_server_init(char *listen_ip, int listen_port);   //socket，bind，listen打包



int main(int argc, char *argv[])
{
  
//省略命令行解析部分
    


    listenfd = socket_server_init(NULL, serv_port);
    
//将监听的数组中的所有文件描述符置-1，然后将第一个位置赋值为listenfd
    for (i = 0; i < ARRAY_SIZE(fds_array); i++)
    {
        fds_array[i] = -1;
    }
    fds_array[0] = listenfd;
    printf("-------------111111111\n");


//开始循环
    for ( ;  ; )
    {
        rv = select(maxfd+1, &rdset, NULL, NULL, NULL);
      //下面判断是新的客户端来连，还是旧的客户端发生事件


//新的客户端来连，创建connfd
        if( FD_ISSET(listenfd, &rdset) ) 
        {
            printf("judge client is listenfd\n");
            connfd = accept(listenfd, (struct sockaddr *)NULL, NULL);
        }
//不是新的，那就是旧的客户端
        else 
        {
                printf("judge is  old connfd\n");
         
                rv = read(fds_array[i], buf, sizeof(buf)；
                buf[j] = toupper(buf[j]);
                write(fds_array[i], buf, sizeof(buf）；
        }



        return 0；
}







static inline void msleep(unsigned long ms)
{
    struct timeval  tv;
    tv.tv_sec = ms/1000;
    tv.tv_usec = (ms%1000)*1000;
    select(0, NULL,NULL, NULL, &tv);
}



static inline void print_usage(char *progname)
{
   //打印程序命令行参数帮助信息
}





int socket_server_init(char *listen_ip, int listen_port)
{
  listenfd = socket(AF_INET, SOCK_STREAM, 0)
 
  setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
  
  bind (listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)
 
  listen(listenfd, 13) 
}

具体代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <time.h>
#include <pthread.h>
#include <getopt.h>
#include <libgen.h>
#include <sys/types.h>
#include <sys/socket.h> 
#include <arpa/inet.h>
#include <netinet/in.h>

//定义一个宏，计算数组元素个数
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))


static  inline  void    msleep(unsigned long ms);  //延时函数的申明
static  inline  void    print_usage(char *progname);  //打印帮助信息函数申明
int     socket_server_init(char *listen_ip, int listen_port);   //socket，bind，listen打包



int main(int argc, char *argv[])
{
    int             listenfd, connfd;
    int             serv_port = 0;
    int             daemon_run = 0;
    char          *progname = NULL;
    int             opt;
    fd_set       rdset;
    int             rv;
    int             i, j;
    int             found;
    int             maxfd = 0;
    char          buf[1024];
    int             fds_array[1024];


    struct  option  long_options[] =
    {
        {"daemon",no_argument, NULL, 'b'},
        {"port", required_argument, NULL,  'p'},
        {"help", no_argument, NULL, 'h' },
        {NULL, 0, NULL, 0}
    };

    progname = basename(argv[0]);

    while ((opt = getopt_long(argc, argv, "bp:h", long_options, NULL)) != -1) 
    {
        switch (opt) 
        {
            case 'b':
                daemon_run = 1;
                break;
            case 'h':
                print_usage(progname);
                return EXIT_SUCCESS;
            case 'p':
                serv_port = atoi(optarg);
                break;        
            
            default:
            break;    
        }   
    }


    if( !serv_port ) 
    {
        print_usage(progname);   
        return -1;
    }
//上面这部分是命令行解析部分
    


    listenfd = socket_server_init(NULL, serv_port);
    if( listenfd < 0 ) 
    {
        printf("ERROR: %s server listen on port %d failure\n", argv[0], serv_port);
        return -2;
    }
    printf("%s server start to listen on port %d\n", argv[0], serv_port);

//判断是否后台运行
    if( daemon_run ) 
    {
        daemon(0, 0);   
    }



//将监听的数组中的所有文件描述符置-1（代表还没有客户端来连接服务器），然后将第一个位置赋值为listenfd（用来监听新来的客户端）
    for (i = 0; i < ARRAY_SIZE(fds_array); i++)
    {
        fds_array[i] = -1;
    }
    fds_array[0] = listenfd;
    printf("-------------111111111\n");


//开始循环
    for ( ;  ; )
    {
        FD_ZERO(&rdset);    //将监听读事件的集合全部清零
        for (i = 0; i < ARRAY_SIZE(fds_array);i++)
        {
            if( fds_array[i] < 0) 
                continue;   
                
            maxfd = fds_array[i]>maxfd ? fds_array[i] : maxfd;
            FD_SET(fds_array[i], &rdset);
        }
        
        printf("before select \n");
        rv = select(maxfd+1, &rdset, NULL, NULL, NULL);
        printf("select back\n");
      
        if(rv < 0)   //返回小于零代表select失败
        {
            printf("select falure :%s\n", strerror(errno));   
            break;
        }
        else if (rv == 0)   返回零代表超时
        {
            printf("select get timeout\n");   
            continue;
        }

        printf("start judge client or listenfd\n");// 接下来开始判断是新的客户端来连，还是旧的clienfd发生事件



//如果是新的客户端来，执行下面的程序
        if( FD_ISSET(listenfd, &rdset) ) 
        {
            printf("judge client is listenfd\n");
            connfd = accept(listenfd, (struct sockaddr *)NULL, NULL);
            if( connfd <0 ) 
            {
                printf("accept new client failure :%s \n", strerror(errno));
                continue;
            }   


            found = 0;
            for (i = 0; i < ARRAY_SIZE(fds_array); i++)
            {
                if( fds_array[i] < 0dai'bi)  //如果集合中是-1 代表这个位置是空的
                {
                    printf("accept new client[%d] and add it into array\n", connfd);   
                    fds_array[i] = connfd;  //将新的客户端文件描述符添加到集合
                    found = 1;
                    break;
                }    
            }
            如果没找到，代表集合已经满了，已经不能再继续接收新的客户端
            if( !found ) 
            {
                printf("accept new client[%d] but full , so refuse it\n", connfd);   
                close(connfd);
            }
        }


//如果判断是旧的客户端发生读写事件，执行小写转大写的功能

        else 
        {

            printf("judge is  old connfd\n");
            for (i = 0; i < ARRAY_SIZE(fds_array); i++)
            {
                if( fds_array[i] < 0 || !FD_ISSET(fds_array[i], &rdset) ) 
                continue;

                if( (rv = read(fds_array[i], buf, sizeof(buf))) <= 0 )
                {
                    printf("socket[%d] read failure or get disconnect.\n", fds_array[i]);   
                    close(fds_array[i]);
                    fds_array[i] = -1;
                }

                else 
                {

                   printf("read success\n");
                   printf("socket [%d] read get %d bytes data \n", fds_array[i], rv); 

                   for (j = 0; j < rv; j++) {
                       buf[j] = toupper(buf[j]);
                   }

                   if( write(fds_array[i], buf, sizeof(buf)) < 0 ) 
                   {
                        printf("socket [%d] write failure: %s\n", fds_array[i], strerror(errno));
                        close(fds_array[i]);
                        fds_array[i] = -1;
                   }
                   printf("\nwrite success %s\n",buf);
                   memset(buf, 0,sizeof(buf));
                }
            }
        }
    }




CleanUp:
    close(listenfd);
    return 0;
}







static inline void msleep(unsigned long ms)
{
    struct timeval  tv;

    tv.tv_sec = ms/1000;
    tv.tv_usec = (ms%1000)*1000;

    select(0, NULL,NULL, NULL, &tv);
}



static inline void print_usage(char *progname)
{
    printf("usage : %s [option]....\n", progname);

    printf("%s is a socket server progname, which used to verity client and echo back string from it\n", progname);
    printf("\nmandatory argument to long option are mandatory for short option too:\n");
    printf("-b[daemon] set program running on backgrounfoo\n");
    printf("-p[port] socket server port address \n");
    printf("-h[help] display this help information \n");

    printf("\nexample: %s -b -p 8999\n", progname);
    return;
}





int socket_server_init(char *listen_ip, int listen_port)
{
    struct sockaddr_in   servaddr;
    int                  rv = 0;
    int                  on = 1;
    int                  listenfd;


    if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) 
    {
        printf("use socket() to creat a tcp socket failure :%s\n", strerror(errno));
        return -1;
    }

    setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(listen_port);

    if( !listen_ip ) 
    {
        servaddr.sin_addr.s_addr = htonl(INADDR_ANY);   
    }
    else 
    {
        if(inet_pton(AF_INET, listen_ip, &servaddr.sin_addr) <= 0) 
        {
            printf("inet_pton() set listen ip address failure \n");   
            rv = -2;
            goto CleanUp;
        }
    }

    if(bind (listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0) 
    {
        printf("use bind() to bind the tcp socket failure :%s\n", strerror(errno));   
        rv = -3;
        goto CleanUp;
    }

    if(listen(listenfd, 13) < 0 ) 
    {
        printf("use bind() to bind the tcp socket failure :%s\n", strerror(errno));   
        rv = -4;
        goto CleanUp;
    }


CleanUp:
    if( rv < 0 ) 
    {
        close(listenfd);   
    }
    else 
    {
        rv = listenfd;
    }


    return rv;

}
blazer小星星
发布了20 篇原创文章 · 获赞 41 · 访问量 4734
私信 关注

猜你喜欢

转载自blog.csdn.net/weixin_46027505/article/details/104836269
今日推荐
富文本编辑器 Quill 2.0 重磅发布，特性、可靠性与开发者体验大幅提升
“开源信徒”周鸿祎开源360智脑大模型
周排行
VS2017编译opensmile具体过程和遇到的问题
PowerEnglish——mini-story3总结
微信小程序 数据库获取字符串 在view中显示换行
Java静态代码块/构造代码块/构造函数/静态变量/成员变量(相关示例)
Keras使用tensorflowjs部署demo
window下用git连接Github
图象的全变分和去噪
LeetCode刷题笔记--119. Pascal's Triangle II
【Linux】进程间通信 - 管道
polyA|ribo-minus|differentiated cell|Genetic heterogeneity
每日归档
更多
2024-04-17(5)
2024-04-16(70)
2024-04-15(42)
2024-04-14(0)
2024-04-13(119)
2024-04-12(38)
2024-04-11(14)
2024-04-10(68)
2024-04-09(5)
2024-04-08(60)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022