基于poll的网络服务端模型

先说一下，poll和select没有太本质的区别，
1.使用poll时，会造成大量的fd的数组在用户态和内核态之间被赋值复制
2.与select函数一样，poll也是去遍历fd集合来获取就绪的fd，这样在fd较多时会造成性能的下降(像网络上连接数量较多的情况，这里建议了解epoll)。
3.监视的fd可能活跃的数量比较少，也会导致性能下降。

再来说一说poll的函数原型

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

fds：指向一个结构体数组首个元素的指针，每个数组元素都是一个stuct pollfd结构，用于指定检测某个给定的fd的条件。

nfds：参数fds结构体数组的长度。nfd_t不需要计算，直接用遍历的size方法。

timeout：poll的超时时间，单位是毫秒。

pollfd的定义如下

 struct pollfd {
     int   fd;         /* file descriptor */
     short events;     /* requested events */
     short revents;    /* returned events */
 };

fd是要检测的文件描述符
events是开发者设置的，可以检测可读可写错误等事件。
revents是poll函数返回时，内核设置的，说明改fd发生了什么事件。

事件宏	事件描述
POLLIN	数据可读
POLLPRI	高优先级数据可读
POLLOUT	数据可写

后面还有很多，可以通过 man poll查看手册

书写这个poll模型的基本思路是一下几步
1.创建服务器的监听socket，放于struct pollfd内，给到容器。
2.遍历容器内部的所有fd是否有可读事件（可根据业务场景改变）
–如果是监听的socket，尝试连接，连接成功后把fd加入到容器内。
–如果是新加入的客户端socket有事件，读取socket里面的内容。

#include <stdio.h>
#include <iostream>  //std
#include <string.h>
#include <errno.h>  //perror 打印一些错误信息
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <poll.h> //利用poll方法实现高可用io
#include <vector>
#include <fcntl.h>
#define IP_ADDR "10.234.19.202"
#define TCP_SERVER_PORT 11000
#define MAX_CLIENT_NUM 3
#define INVALID_SOCKET -1
#define RECV_BUF_SIZE 1024
#define INVALID_FD -1
int main(int argc, char *argv[])
{

    std::cout << "Tcp_Server_Started  "<< std::endl;
	int ret = 0;

	int serverSocketFd = 0;
	serverSocketFd = socket(AF_INET, SOCK_STREAM, 0);
	if (serverSocketFd == INVALID_SOCKET)
	{
		std::cout << "creat socket failed!"  << std::endl;
		return -1;
	}

	sockaddr_in local_addr;
	sockaddr_in remote_addr;

	memset(&local_addr, 0x0, sizeof(sockaddr_in));
	memset(&remote_addr, 0x0, sizeof(sockaddr_in));

	local_addr.sin_addr.s_addr = inet_addr(IP_ADDR);
	local_addr.sin_family = AF_INET;
	local_addr.sin_port = htons(TCP_SERVER_PORT);

	int addrlen_ = sizeof(struct sockaddr_in);
	//绑定套接字描述符和指定的ip 端口
	ret = bind(serverSocketFd, (sockaddr*)&local_addr, addrlen_);
	perror("bind");
	if ( ret == -1)
	{
		std::cout << "bind socket and addr failed !" << std::endl;
		close(serverSocketFd);
		return ret;
	}

	if (-1 == listen(serverSocketFd, MAX_CLIENT_NUM))
	{
		std::cout << "listen socket failed  !"  << std::endl;
		close(serverSocketFd);
		// WSACleanup();
		return -1;
	}
	
    /*常见一个容器 容纳pollfd 一种数据结构 里面有一个变量是文件描述符*/
    std::vector<pollfd> fds;
    pollfd listen_fd_info;
    listen_fd_info.fd = serverSocketFd;
    listen_fd_info.events = POLLIN;
    listen_fd_info.revents = 0;
    
    fds.push_back(listen_fd_info);

    bool exist_invalid_fd;
    int n;
    /*开始准备接收消息*/
    while(true)
    {
        exist_invalid_fd = false;
        /* 第一个是待检测得fd事件，第二个是fd结构体数组得长度，1000是检测超时时间，单位是毫秒*/
        n = poll(&fds[0],fds.size(),1000);
        if( n < 0 )
        {   
            /*信号被中断*/
            if(errno == EINTR)
            {
                continue;
            }
            break;
        }
        
        else if (n == 0)
        {
            /*超时继续*/
            continue;
        }
        /*如果前面得判断都走过了，说明有可读事件*/
        for(size_t i = 0 ; i < fds.size() ; i++)
        {
            std::cout<<"zzz"<<std::endl;
            /*判断监听事件是否是我们想要得*/
            if(fds[i].revents == POLLIN)
            {
                /*判断是否是我们监听得socket*/
                if(fds[i].fd == serverSocketFd )
                {
                    //监听socket，接收新连接
                    struct sockaddr_in clientaddr;
                    socklen_t clientaddrlen = sizeof(clientaddr);
                    /*接收客户端的连接并加入到fds合集中*/
                    int clientfd = accept(serverSocketFd,(struct sockaddr *)&clientaddr,&clientaddrlen);
                    if(clientfd != -1)
                    {
                        /*将接收的clientfd设置为非阻塞的*/
                        int oldsocketFlag = fcntl(clientfd,F_GETFL,0);
                        int newsocketFalg = oldsocketFlag | O_NONBLOCK;
                        if( fcntl(clientfd , F_SETFL, newsocketFalg) == -1)
                        {
                            close(clientfd);
                            std::cout<<"set clientfd to nonblock error"<<std::endl;
                        }
                        else
                        {
                            std::cout<<"accpet success!"<<std::endl;
                            struct pollfd client_fd_info;
                            client_fd_info.fd = clientfd;
                            client_fd_info.events = POLLIN;
                            client_fd_info.revents = 0;
                            fds.push_back(client_fd_info);
                        }
                    }
                    else
                    { 
                       std::cout<<"error ,clientfd = "<<clientfd<<"!"<<std::endl;
                    }
                }
                /*前面一个判断说明不是本端监听的fd，那么是我们新加入的客户端fd，读取客户端的fd*/
                else
                {
                    char buf[RECV_BUF_SIZE] = {0};
                    int tempsize = recv(fds[i].fd,buf,RECV_BUF_SIZE,0);
                    /*如果读取小于等于0*/
                    if( tempsize <= 0)
                    {
                        if(errno != EINTR && errno!= EWOULDBLOCK)
                        {
                            /*出错或者对端关闭了连接，关闭对应的clientfd，没设置无效标志位*/
                            /*创建一个迭代器来遍历容器*/
                            for(std::vector<pollfd>::iterator iter = fds.begin();iter != fds.end(); ++iter)
                            {
                                if( iter->fd == fds[i].fd)
                                {
                                    std::cout<<"client disconnected ,clientfd = "<<fds[i].fd<<std::endl;
                                    close(fds[i].fd);
                                    iter->fd =INVALID_FD;
                                    exist_invalid_fd = true ;
                                    break;
                                }
                            }
                        }
                    }
                    else
                    {
                        std::cout<<"recv buf from client:"<<buf<<",clientfd:"<<fds[i].fd<<std::endl;
                    }
                }
            }
            else if(fds[i].revents == POLLERR)
            {
                //TODO:异常处理机制 
            }
        }
        
        /*清理工作,如果存在无效的fd，则清理之*/
        if(exist_invalid_fd)
        {
            //统一清理无线的fd
            for(std::vector<pollfd>::iterator iter = fds.begin(); iter != fds.end();)
            {
                if(iter->fd == INVALID_FD)
                {
                    iter = fds.erase(iter);
                }
                else
                {
                    iter++;
                }
            }
        }
    }

    std::cout<<"exit normal"<<std::endl;
    return 0;
}

最后有一点需要注意的是，poll的触发模式是水平触发模式(Level Trigger),这种模式的意思是，只要fd里面有待检测的事件发生，但是应用不做处理的话，会一直poll能够一直检测到事件，直到处理事件为止。

另外与之对应的还有边缘触发模式(Edge Trigger),epoll对这个模式进行了实现。具体两种触发模式的区别，以及应用在读写操作时的区别，参考《C++服务器开发精髓》的p367。