c++应用网络编程之十Linux下的Poll模式

fpcc

于 2024-10-01 19:49:52 发布

阅读量279

点赞数 3

分类专栏： C++ 网络编程文章标签：网络 linux c++

本文链接：https://blog.csdn.net/fpcc/article/details/142673949

版权

C++ 同时被 2 个专栏收录

254 篇文章 40 订阅

订阅专栏

网络编程

9 篇文章 1 订阅

订阅专栏

一、Poll模式

在上一篇文章中提到了Select模式的缺点。既然有缺点，就要改正。但是直接在Select模式上修改不太现实，那么就推出一个新的模式不更香么？poll模式就应运而生了。不过，罗马不是一天建成的，poll模式也只是对select模式进行了局部的调优，仍然有着大幅改进的空间。

二、特点

poll模式的特点，基本和select模式一致。不同的是，通过自定义遍历fd的数组来解决了在select内核中很难改动的fd上限1024个（一般修改上限后需要重新编译内核）。这对于select来说，是一个巨大的进步。特别是对于一些监控客户端很多，但实际通信量并不多的场景下，其有着非常强的应用需求。
但是它的缺点仍然是select除此之外的未解决的问题。特别是在监听fd增大后，遍历所带来的开销进一步增大，所以一定要平衡好数量和效率的问题。所以产，poll可以认为是个过渡的模型。真正在实际应用中，一般很难看到。
同样需要说明的，它也可以用在客户端。不过一般一个客户端用这个就有点鸡肋了，除非有什么特别的要求。

三、数据结构和API

poll的数据结构也不复杂，看一下其相关代码：

#define POLLIN		0x0001     //普通或优先级带数据可读
#define POLLPRI		0x0002     //高优先级数据可读
#define POLLOUT		0x0004     //普通数据可写
#define POLLERR		0x0008     //错误
#define POLLHUP		0x0010     //挂起
#define POLLNVAL	0x0020     //描述字不是一个打开的文件

/* The rest seem to be more-or-less nonstandard. Check them! */
#define POLLRDNORM	0x0040  //普通数据可读
#define POLLRDBAND	0x0080  //优先级带数据可读
#ifndef POLLWRNORM
#define POLLWRNORM	0x0100     //普通数据可写
#endif
#ifndef POLLWRBAND
#define POLLWRBAND	0x0200     //优先级带数据可写
#endif
#ifndef POLLMSG
#define POLLMSG		0x0400
#endif
#ifndef POLLREMOVE
#define POLLREMOVE	0x1000
#endif
#ifndef POLLRDHUP
#define POLLRDHUP       0x2000
#endif

#define POLLFREE	(__force __poll_t)0x4000

#define POLL_BUSY_LOOP	(__force __poll_t)0x8000

struct pollfd {
	int fd;//监听的文件描述符
	short events;//该文件描述符的事件掩码，开发者设置
	short revents;//文件描述符的操作结果事件掩码，内核在调用返回时设置
};

一个pollfd对象代表着一个监听的文件描述符即Socket。如果需要监听多个Socket则需要创建一个pollfd对象数组通过接口函数poll进行处理。如果需要监听多类事件，则需要使用类似POLLIN | POLLRDNORM设置pollfd对象中events域。之后可以在调用poll接口后使用类似fds[i].revents & POLLIN的方法来检测相关事件是否发生，如果发生则可以进行相关事件的操作。

四、例程

poll的使用真心话，没有在实际的场景中使用过，所以只能简单的看一下代码：

#include <netinet/in.h>
#include <sys/types.h>  
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <poll.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <iostream>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <atomic>

using namespace std;
#define BUF_LEN 1024
#define FD_LEN 1000

char DataBuf[BUF_LEN] = {0};

class Poller
{
public:
    Poller();
    ~Poller();
    int InitServer(unsigned short port = 8888);
    void Accept();
    void StartServer();
    void Recv();
    void Quit(){this->isRun = false;}
private:
    int listenFd = -1;            
    struct pollfd fds[FD_LEN];
    int nfds = -1;
    bool isRun = true;

    struct sockaddr_in server_addr;
    socklen_t server_addr_len;
};

Poller::Poller()
{
}

Poller::~Poller()
{
    for(auto &fd:fds)
    {
      if (fd>=0)
      {
        shutdown(fd,2);
        close(fd);
      }
    }
}

void Poller::InitServer(unsigned short port)
{
    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    server_addr.sin_port = htons(port);

    listenFd = socket(PF_INET, SOCK_STREAM, 0);
    if (listenFd < 0)
    {
        perror("create socket err!");
        exit(1);
    }
    int opt = 1;
    setsockopt(listenFd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    if (-1 == (bind(listenFd, (struct sockaddr *)&server_addr, sizeof(server_addr))))
    {
        perror("bind err!");
        exit(1);
    }

    if (-1 == listen(listenFd, 3))
    {
        perror("listen err!");
        exit(1);
    }
}

void Poller::Accept()
{
    struct sockaddr_in client_addr;
    socklen_t client_addr_len = sizeof(client_addr);

    int clientFd = accept(listenFd, (struct sockaddr *)&client_addr, &client_addr_len);
    if (clientFd < 0)
    {
        perror("poll accept error!");
        exit(1);
    }

    int count = 0;
    for (count = 1; count < FD_LEN; ++count)
    {
        if (fds[count].fd < 0)
        {
            fds[count].fd = clientFd;
            break;
        }
    }

    if (count == FD_LEN)
    {
        perror("client is too much!");
        exit(1);
    }

    fds[count].events = POLLIN;  
    nfds = count > nfds ? count : nfds;
}

void Poller::StartServer()
{
    fds[0].fd = listenFd;
    fds[0].events = POLLIN;
    nfds = 0;

    for (int id = 1; id < FD_LEN; ++id)
    {
      fds[id].fd = -1;
    }

    while (isRun)
    {
        int nums = poll(fds, nfds + 1, -1);
        if (nums < 0)
        {
            perror("poll err!");
            exit(1);
        }

        if (nums == 0)
        {
            continue;
        }

        if (fds[0].revents & POLLIN)
        {
          //fd 0 is listen
          Accept();
        }
        else
        {
          Recv()
        }
    }
}

void Poller::Recv()
{
    for (int i = 1; i < FD_LEN; ++i)
    {
        if (fds[i].fd < 0){
            continue;
        }

        //read
        if (fds[i].revents & POLLIN)
        {
            int fd = fds[i].fd;
            bool isClosed = false;

            int len = 0;
            recv(fd, &len, sizeof(len), 0); // recv data len

            memset(DataBuf,0,len);
            int num = 0;
            while (num < len)
            {
                int len = recv(fd, DataBuf + num, len - num, 0);
                if (len < 0)
                {
                    isClosed = true;
                    break;
                }
                num = num + len;
            }

            if (num >= len)
            {
                int ret = send(fd, DataBuf, len, 0);
                if (ret< 0)
                {
                    perror << "send data error!";
                    isClosed = true;
                }
            }

            if (isClosed)
            {
                shutdown(fd,2);
                close(fd);
                fds[i].fd = -1;
            }
        }
    }
}

int main()
{
    Poller pollServer();
    pollServer.InitServer();
    pollServer.StartServer();
    gechar();
    return 0;
}