IO多路復用之poll

poll提供的功能與select類似,與select在本質上沒有多大差別，管理多個描述符也是進行輪詢，但poll比select的優點是，不限制所能監視的描述符的數目，但隨著所監視描述符的數目的增加，性能也會下降

函數原型：

#include <poll.h>

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

返回值：成功時，poll()返回結構體中revents域不為0的文件描述符個數；如果在超時前沒有任何事件發生，返回0；失敗返回-1

參數：

fds:結構體指針，該結構體結構如下：

        struct pollfd{

    　    　    int fd;               //所感興趣的文件描述符

    　　        short events;    //用于指定等待的事件

    　　        short revents;   //用于指定poll返回時，在該文件描述符上實際發生了的事件

    　　    };

每一個pollfd結構體制定了一個被監視文件描述符，可傳遞多個該結構體，指示poll監視多個文件描述符

nfds:要監視的描述符的個數

timeout:單位（微秒），timeout指定等待的毫秒數，無論I/O是否準備好，poll都會返回，指定為負數值表示無限超時，使poll()一直掛起直到一個指定事件發生；timeout為0指示poll調用立即返回并列出準備好I/O的文件描述符，但并不等待其它的事件，立即返回

events域中請求的任何事件都可能在revents域中返回。合法的事件如下：

      POLLIN 　　　　　　　　有數據可讀

      POLLPRI　　　　　　　　有緊迫數據可讀

　　POLLOUT　　　　　　     寫數據不會導致阻塞

　　POLLRDNORM 　　　　  有普通數據可讀。

　　POLLRDBAND　　　　　 有優先數據可讀。

　　POLLWRNORM　　　　　寫普通數據不會導致阻塞。

　　POLLWRBAND　　　　   寫優先數據不會導致阻塞。

　　POLLMSGSIGPOLL 　　 消息可用。

　　此外，revents域中還可能返回下列事件：
　　POLLER　　           指定的文件描述符發生錯誤。

　　POLLHUP　　         指定的文件描述符掛起事件。

　　POLLNVAL　　       指定的文件描述符非法。

      這些事件在events域中無意義，因為它們在合適的時候總是會從revents中返回。

　　POLLIN | POLLPRI等價于select()的讀事件，POLLOUT |POLLWRBAND等價于select()的寫事件。POLLIN等價于POLLRDNORM |POLLRDBAND，而POLLOUT則等價于POLLWRNORM。例如，要同時監視一個文件描述符是否可讀和可寫，我們可以設置 events為POLLIN |POLLOUT。在poll返回時，我們可以檢查revents中的標志，對應于文件描述符請求的events結構體。如果POLLIN事件被設置，則文件描述符可以被讀取而不阻塞。如果POLLOUT被設置，則文件描述符可以寫入而不導致阻塞。這些標志并不是互斥的：它們可能被同時設置，表示這個文件描述符的讀取和寫入操作都會正常返回而不阻塞。

示例代碼如下：

編寫一個echo server程序，功能是客戶端向服務器發送信息，服務器接收輸出并原樣發送回給客戶端，客戶端接收到輸出到終端

server_poll.c

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

#define _BLOCKLOG_ 6

void usage(char *_proc)
{
    printf("%s [ip] [port]\n",_proc);
}

int create(char *_ip,int _port)
{
    int listen_fd=socket(AF_INET,SOCK_STREAM,0);
    if(listen_fd<0){
        perror("socket");
        exit(1);
    }   
    
    struct sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_port=htons(_port);
    local.sin_addr.s_addr=inet_addr(_ip);

    struct linger lig;
    int iLen;
    lig.l_onoff=1;
    lig.l_linger=0;
    iLen=sizeof(struct linger);
    setsockopt(listen_fd,SOL_SOCKET,SO_LINGER,(char *)&lig,iLen);

    if(bind(listen_fd,(struct sockaddr*)&local,sizeof(local))<0){
        perror("bind");
        exit(2);
    }

    if(listen(listen_fd,_BLOCKLOG_)<0){
        perror("listen");
        exit(3);
    }

    return listen_fd;
}

int main(int args,char *argv[])
{
    if(args!=3){
        usage(argv[0]);
        return 1;
    }   

    char *ip=argv[1];
    int port=atoi(argv[2]);
    //創建監聽描述符并綁定
    int listen_fd=create(ip,port);

    nfds_t nfds=64;
    struct pollfd fds[nfds];

    //初始化描述符
    int i=0;
    for(;i<nfds;++i){
        fds[i].fd=-1;
    }  
    
    //添加監聽描述符
    fds[0].fd=listen_fd;
    fds[0].events=POLLIN;

    struct sockaddr_in client;
    socklen_t len;

    char buf[1024];
    int maxi=0;

    int done=0;
    while(!done){
        int timeout=5000;
        switch(poll(fds,maxi+1,timeout)){
            case -1:
                perror("poll");
                break;
            case 0:
                printf("poll timeout...\n");
                break;
            default:
                {
                    int i=0;
                    for(;i<nfds;++i){
                        if(fds[i].fd==listen_fd && (fds[i].revents&POLLIN)){//listen event happend
                            int new_socket=accept(listen_fd,(struct sockaddr*)&client,&len);
                            if(new_socket<0){
                                perror("accept");
                                continue;
                            }else{
                                printf("get a connection...%s:%d\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
                                int i=0;
                                //將新的連接和讀事件添加到數組中
                                for(;i<nfds;++i){
                                    if(fds[i].fd<0){
                                        fds[i].fd=new_socket;
                                        fds[i].events=POLLIN;
                                        ++maxi;//更新客戶連接的文件描述符的個數
                                        break;
                                    }
                                }
                            }
                        }else if(fds[i].fd>0 && (fds[i].revents&POLLIN)){//normal events happend
                                //接收客戶端發來的消息
                            ssize_t _size=read(fds[i].fd,buf,sizeof(buf)-1);
                            if(_size<0){
                                perror("read");
                            }else if(_size==0){//client closed
                                printf("client shutdown\n");
                                close(fds[i].fd);
                                fds[i].fd=-1;
                                continue;
                            }else{
                                buf[_size]='\0';
                                printf("client# %s",buf);
                                //向客戶端發送消息
                                if(write(fds[i].fd,buf,sizeof(buf)-1)<0){
                                    perror("write");
                                }
                            }
                        }
                    }
                    break;
                }
                break;
        }
    }

    return 0;
}

client_poll.c

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <netinet/in.h>

void usage(char *proc)
{
    printf("%s [ip] [port]\n",proc);
}

int creat_socket()
{
    int fd=socket(AF_INET,SOCK_STREAM,0);
    if(fd<0){
        perror("socket");
        exit(1);
    }

    return fd;
}

int main(int argc,char* argv[])
{
    if(argc!=3){
        usage(argv[0]);
        exit(1);
    }

    int fd=creat_socket();

    int _port=atoi(argv[2]);
    struct sockaddr_in addr;
    addr.sin_family=AF_INET;
    addr.sin_port=htons(_port);
    inet_aton(argv[1],&addr.sin_addr);
    socklen_t addrlen=sizeof(addr);
    if(connect(fd,(struct sockaddr*)&addr,addrlen)<0){
        perror("connect");
        exit(2);
    }

    char buf[1024];
    while(1){
        memset(buf,'\0',sizeof(buf));
        printf("Please Enter:");
        fgets(buf,sizeof(buf)-1,stdin);
        if(send(fd,buf,sizeof(buf)-1,0)<0){
            perror("send");
            continue;
        }

        ssize_t _size=recv(fd,buf,sizeof(buf)-1,0);
        if(_size>0){
            buf[_size]='\0';
            printf("echo->%s",buf);
        }
  }
  return 0;
}

運行結果：

服務器端運行結果：

客戶端1運行結果：

客戶端2運行結果：

最后還有一點，poll()會自動把revents域設置為0，不需要我們手動的去設置

測試程序如下：

以下程序片段只是在上面代碼的基礎上添加了幾行代碼，為看的更清楚，我用紅色注釋了這幾行代碼

運行出來的結果如下：

現在對上面運行結果進行分析，為簡單起見，我們只關注四個結構體，所以以四行為單位

可看到第一次（前四行）的revents都為隨機值

第二次(次四行）poll()函數把fd=3的描述符中revents設置為0

第四次poll()函數把fd=3的描述符中revents設置為1（因為此時監聽到了客戶端請求）所以接下來有：

get a connection...1.0.0.0:0  這條消息

第五次fd=3的revents還是為1，因為此時還沒有執行poll()，fd=4的revents是隨機值

第六次fd=3和fd=4的events都為1，它們都添加了讀事件，而fd=3的revents被poll設置為了0，fd=4的revents為1（因為客戶端發送了條消息，使讀事件發生，因此有下面一條消息：）

client# hello 

第七次和第六次的一致，因為還未被poll()設置

第八次和第七次的一致，但此時fd=4的revents=1是因為客戶端按下了Ctrl+c,所以接下來會有：

client shutdown  

第九次把fd=4從數組中去掉

《完》