Linux中select实现高性能服务器以及与多进程服务器对比

于 2017-06-11 22:43:24 发布
阅读量751 收藏 1
点赞数
分类专栏： 计算机网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lishitao_578/article/details/73071871
版权

I/O复用之select模型：
I/O复用使得程序能够同时监听多个文件描述符，但I/O复用本身也是阻塞的，并且当一个或多个文件描述符准备就绪时，如果不采用其他措施，程序只能按顺序处理其中的每个文件描述符。如果要使程序能够并行运行，只能使用多进程或多线程的方式。
Linux中I/O复用系统调用主要有select和poll还有epoll三种，这篇博客主要讨论的是select
select函数API：
这里写图片描述
select的参数中第一个是nfds是所有监听的文件描述符的个数+1；
第二个参数是readfds是要进行读操作的文件描述符集，第三个是进行写操作的文件描述符的集合，第四个是错误的文件描述符集，第四个参数timeout是一个结构体，结构体的内容如下：
这里写图片描述
如果是把结构体中的两个变量都设置为0，那么select立即返回，如果把timeout设置为NULL那么select一直阻塞到知道一某个文件描述符准备就绪。
select的返回值：
select成功后返回值为准备就绪的文件描述符的个数，如果返回值是0的话就说明等待超时，返回值为负值就说明select执行失败。
select实现高性能服务器代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<unistd.h>
#include<netinet/in.h>
#include<sys/select.h>
#include<sys/time.h>
int array_fds[1024];
static void usage(char* proc)
{
    printf("usage:%s [ip][port]",proc);
}
ssize_t startup(char* ip,int port)
{
    ssize_t sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        exit(2);
    }
    int flag=1;
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&flag,sizeof(flag));
    struct sockaddr_in server_addr;
    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(port);
    server_addr.sin_addr.s_addr=inet_addr(ip);
    if(bind(sock,(struct sockaddr*)&server_addr,sizeof(server_addr))<0)
    {
        perror("bind");
        exit(3);
    }
    if(listen(sock,10)<0)
    {
        perror("listen");
        exit(4);
    }
    return sock;
}
int main(int argc,char* argv[])
{
    if(argc!=3)
    {
        usage(argv[0]);
        exit(1);
    }
    int listen_sock=startup(argv[1],atoi(argv[2]));
    fd_set rfds;
    fd_set wfds;
    int maxfd=0;
    int array_size=sizeof(array_fds)/sizeof(array_fds[0]);
    array_fds[0]=listen_sock;
    int i=1;
    for(;i<array_size;++i)
    {
        array_fds[i]=-1;
    }
    while(1)
    {
        struct timeval _timeout={2,0};
        FD_ZERO(&rfds);
        maxfd=-1;
        for(i=0;i<array_size;++i)
        {
            if(array_fds[i]>0)
            {
                FD_SET(array_fds[i],&rfds);
                FD_SET(array_fds[i],&wfds);
                if(array_fds[i]>maxfd)
                {
                    maxfd=array_fds[i];
                }
            }
        }
        switch(select(maxfd+1,&rfds,&wfds,NULL,NULL))
        {
            case 0:
                printf("timeout...");
                break;
            case -1:
                perror("select");
                break; 
            default:
                { 
                    int j=0;
                    for(;j<array_size;++j)
                    {
                        if(array_fds[j]<0)
                        {
                            continue;
                        }
                        if(j==0&&FD_ISSET(array_fds[j],&rfds))
                        {
                            struct sockaddr_in client_addr;
                            socklen_t len=sizeof(client_addr);
                            int new_sock=accept(array_fds[j],(struct sockaddr*)&client_addr,&len);
                            if(new_sock<0)
                            {
                                perror("accept");
                                exit(5);
                            }
                            //printf("get new connect:(%s:%d)",inet_ntoa(client_addr.sin_addr),ntohs(client_addr.sin_port));
                            int k=1;
                            for(;k<array_size;k++)
                            {
                                if(array_fds[k]<0)
                                {
                                    array_fds[k]=new_sock;
                                    break;
                                }
                                else if(k==array_size)
                                {
                                    close(new_sock);
                                }
                                else
                                {
                                    continue;
                                } 
                            } 
                        }
                        if(j!=0&&FD_ISSET(array_fds[j],&rfds))
                        {
                            char buff[1024];
                            memset(buff,0,sizeof(buff)/sizeof(buff[0]));
                            int s=read(array_fds[j],buff,sizeof(buff));
                            if(s>0)
                            {
                                buff[s]='\0';
                                printf("client say:%s",buff);
                                if(j!=0&&FD_ISSET(array_fds[j],&wfds))
                                {   
                                write(array_fds[j],buff,strlen(buff));
                                }
                        /*if(j!=0&&FD_ISSET(array_fds[j],&wfds))
                        {
                            write(array_fds[j],buff,strlen(buff));
                            close(array_fds[j]);
                            array_fds[j]=-1;
                            //留着写write
                        }
                        */
                            }
                            else if(s==0)
                            {
                                printf("client quit!\n");
                                fflush(stdout);
                                close(array_fds[j]);
                                array_fds[j]=-1;//write就在这修改一下

                                /*if(!FD_ISSET(array_fds[j],&wfds))
                                {
                                    close(array_fds[j]);
                                    array_fds[j]=-1;
                                }*/
                            }
                            else
                            {
                                perror("read");
                                close(array_fds[j]);
                                array_fds[j]=-1;//write就在这修改一下
                            } 
                        }
                    }
                    break;
                    }
                }

    }
    return 0;
}

和多进程服务器相比select服务器的优点：
可以同时检测多个文件描述符，相比之下还是效率较高
缺点：
一、能检测的文件描述符是有限的，Linux中默认是1024个，对于大一点的服务器就都不够用了。
二、每一次都需要在内核态把文件描述符遍历一边，如果文件描述符很多，那么这个开销是巨大的。
三、每一次都要把文件描述符集从用户态拷到内核态，这个开销也是很大的。
client客户端，使用dup/dup2进行网络输出重定向
相关API：
这里写图片描述
dup函数参数是一个文件描述符，返回值是该文件描述符的一份备份。
换句话说就是两个文件描述符都指向同一个文件，通过这两个文件描述符都可以访同一个同一个文件。
dup2的参数是一个旧的文件描述符和一个新的文件描述符，就是把新的描述符修改指向，让第二个文件描述符指向第一个文件描述符指向的文件。
代码：

#include<stdio.h>
#include<unistd.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<string.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<fcntl.h>
#include<arpa/inet.h>
#include<sys/stat.h>
static void usage(char* proc)
{
    printf("usage:%s[server ip][server port]",proc);
}
int main(int argc,char*argv[])
{
    if(argc!=3)
    {
        usage(argv[0]);
        exit(1);
    }
    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        exit(2);
    }
    struct sockaddr_in server_addr;
    server_addr.sin_family=AF_INET;
    server_addr.sin_port=htons(atoi(argv[2]));
    server_addr.sin_addr.s_addr=inet_addr(argv[1]);
    if(connect(sock,(struct sockaddr*)&server_addr,sizeof(server_addr)))
    {
        perror("connect");
        exit(3);
    }
    int oldfd=dup(STDOUT_FILENO);
    char buff[1024];
    while(1)
    {
        printf("Enter Please:");
        fflush(stdout);
        dup2(sock,STDOUT_FILENO);
        int s=read(0,buff,sizeof(buff)-1);
        if(s>0)
        {
            if(buff[0]=='\n')
            {
                dup2(oldfd,STDOUT_FILENO);
                continue;
            }
            if(strncmp(buff,"quit",4)==0)
            {
                break;
            }
            buff[s]=0;
            printf("%s",buff);
            fflush(stdout);
            dup2(oldfd,STDOUT_FILENO);
            int _s=read(sock,buff,sizeof(buff)-1);
            if(_s>0)
            {
                buff[_s]=0;
                printf("server echo:#%s",buff);
            }
            else if(s<=0)
            {
                continue;
            }
        }
    }
    close(sock);
    close(oldfd);
    return 1;
}

这篇文章就讲到这了，如果有问题，或者文章有错误，请评论，求老司机带路。

我爱吃青菜ooo
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值