簡介

poll是linux的事件輪詢機制函式，每個程序可以管理一個pollfd佇列，由poll函式進行事件註冊和查詢。

pollfd資料結構：

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

fd是檔案描述符，用來指示linux給當前pollfd分配的檔案。程式設計時需要給events註冊我們想要的事件，之後使用poll函式對pollfd佇列進行輪詢，輪詢結束後，revents

poll函式結構：

#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);

fds是佇列的對頭指標，nfds是佇列的長度，timeout是時間控制機制，超時返回0，計時使用毫秒。

上述所有的引數參考：http://man7.org/linux/man-pages/man2/poll.2.html

程式碼例項

開發環境： Ubuntu 18.04 LTS
編譯器：g++ 7.2

伺服器

伺服器接收客戶端的請求，並向客戶端返回客戶端發來的訊息。

/*
 * 藉助於poll實現I/O複用模型，
 * poll與select最大的區別在於該模型基於事件驅動。
 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/ioctl.h>
#include <sys/poll.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <errno.h>
 

#include <string.h>
#include <unistd.h>

#define TRUE 1
#define FALSE 0

int main(int argc, char* argv[]) {
  if (argc != 2) {
    printf("Usage: %s <port of server>\n", argv[0]);
    return -1;
  }

  int len, rc, on = 1;
  int listen_sd = -1, new_sd = -1;
  int end_server = FALSE, compress_array = FALSE;
  int close_conn;
  char buffer[80];
  struct sockaddr_in addr;
  int timeout;
  struct pollfd fds[200];  // poll佇列
  int nfds = 1, current_size = 0;

  int port = atoi(argv[1]);
  if (port <= 1024) {
    perror("port error\n");
    return -1;
  }

  bzero(&addr, sizeof(addr));
  addr.sin_family = AF_INET;
  addr.sin_port = htons(port);
  addr.sin_addr.s_addr = htonl(INADDR_ANY);

  listen_sd = socket(AF_INET, SOCK_STREAM, 0);
  if (listen_sd < 0) {
    perror("socket() error\n");
    return -1;
  }

  rc = setsockopt(listen_sd, SOL_SOCKET, SO_REUSEADDR,
                  (char*)&on, sizeof(on));

  if (rc < 0) {
    perror("setsockopt() failed\n");
    close(listen_sd);
    return -1;
  }
  
  rc = ioctl(listen_sd, FIONBIO, (char*)&on);
  if (rc < 0) {
    perror("setsockopt() failed\n");
    close(listen_sd);
    return -1;
  }

  rc = bind(listen_sd, (struct sockaddr*)&addr, sizeof(addr));
  if (rc < 0) {
    perror("listen() error\n");
    close(listen_sd);
    return -1;
  }

  memset(fds, 0, sizeof(fds));
  fds[0].fd = listen_sd;
  fds[0].events = POLLIN;
  
  timeout = (3 * 60 * 1000);

  rc = listen(listen_sd, 32);
  if (rc < 0) {
    perror("listen() failed\n");
    close(listen_sd);
    return -1;
  }

  do {
    printf("Waiting on poll()...\n");
    rc = poll(fds, nfds, timeout);
    if (rc < 0) {
      perror("poll() failed\n");
      break;
    }
    if (rc == 0) {
      printf("poll timed out. End porgram\n");
      break;
    }

    current_size = nfds;
    for (int i = 0; i < current_size; ++i) {
      if (fds[i].revents == 0)  // 沒有事件的狀態 
        continue;

      if (fds[i].revents != POLLIN) {  // 必須是寫入事件！
        printf("Error! revents = %d\n", fds[i].revents);
        end_server = TRUE;
        break;
      }

      if (fds[i].fd == listen_sd) {  // 監聽到新的訊號
        printf("Listening socket is readable\n");

        do {
          new_sd = accept(listen_sd, NULL, NULL);
          if (new_sd < 0) {
            if (errno != EWOULDBLOCK) {
              perror("accept() failed\n");
              end_server = TRUE;
            }
            break;
          }

          printf("New incomming connection - %d\n", new_sd);
          fds[nfds].fd = new_sd;
          fds[nfds].events = POLLIN;
          nfds++;
        } while (new_sd != -1);
      } else {  // 已經建立連線的socket收到訊息
        printf("Descriptor %d is readable\n", fds[i].fd);
        close_conn = FALSE;

        do {
          // 處理接收到客戶端的資訊，死迴圈是為了接收完所有可能的資料
          // 注意這裡，recv本身是一個阻塞的函式，所以只要客戶端不主動關閉連線，
          // 那麼伺服器會一直阻塞在這裡，又因為使用了while(TRUE)方式迴圈接收，
          // 因此出現瞭如果使用多個客戶端進行連線，只有當前面的關閉連線後，
          // 後面的才會收到資料。在高效能的伺服器程式設計中，客戶端的連線應該使用
          // 多執行緒或者多程序的方式處理。如果資源充足，應該給每個客戶端一個程序
          // 或者執行緒，當然這樣可能也會出現資源不足的情況。更好的方式是多執行緒(程序)結合
          // 心跳檢測機制，把下面的send傳送資料替換成心跳函式。如果收不到心跳，
          // 就認定已經斷線，此時把客戶端的連線剔除即可。本例子中客戶端主動斷開
          // 連線也會被剔除，因為send函式收不到回覆了。
          // 當然，這個例子只是一個示範poll的作用，沒有那麼複雜。
          rc = recv(fds[i].fd, buffer, sizeof(buffer), 0);
          if (rc < 0) {
            if (errno != EWOULDBLOCK) {
              perror("recv() failed\n");
              close_conn = TRUE;
            }
            break;
          }
          if (rc == 0) {
            printf("Connection closed\n");
            close_conn = TRUE;
            break;
          }

          len = rc;
          printf("%d bytes received\n", len);
          rc = send(fds[i].fd, buffer, len, 0);
          if (rc < 0) {
            perror("send() failed\n");
            close_conn = TRUE;
            break;
          }
        } while (TRUE);

        if (close_conn) {
          close(fds[i].fd);
          fds[i].fd = -1;
          compress_array = TRUE;
        }
      } 
    }

    // 壓縮poll佇列，就是順序表刪除中間節點的方法
    // 後邊的資料依次覆蓋前邊的，時間複雜度是O(n)
    if (compress_array) {
      compress_array = FALSE;
      for (int i = 0; i < nfds; ++i) {
        if (fds[i].fd == -1) {
          for (int j = i; j < nfds; ++j) {
            fds[i].fd = fds[j + 1].fd;
          }
          --i;
          --nfds;
        }
      }
    }

  } while(end_server == FALSE);

  // 清理所有開啟的socket
  for (int i = 0; i < nfds; ++i) {
    if (fds[i].fd >= 0) {
      close(fds[i].fd);
    }
  }

  return 0;
}

客戶端

每隔2秒向伺服器傳送一次資訊。

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

int main(int argc, char* argv[]) {
  if (argc != 3) {
    printf("Usage: %s <ip of server> <port of server>\n", argv[0]);
    return -1;
  } 

  int port = atoi(argv[2]);
  if (port < 1024) {
    perror("port error\n");
    return -1;
  }

  struct sockaddr_in serv_addr;
  bzero(&serv_addr, sizeof(serv_addr));
  
  serv_addr.sin_family = AF_INET;
  serv_addr.sin_port = htons(port);
  if (inet_pton(AF_INET, argv[1], &serv_addr.sin_addr.s_addr) < 0) {
    perror("IP error\n");
    return -1;
  }

  int socketfd = socket(AF_INET, SOCK_STREAM, 0);
  if (socketfd < 0) {
    perror("socket() error\n");
    return -1;
  }

  if (connect(socketfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
    perror("connect() error\n");
    return -1;
  }

  char buffer[80];
  memset(buffer, 0, sizeof(buffer));

  int i = 0;
  while(1) {
    int rc = send(socketfd, buffer, sizeof(buffer), 0);
    if (rc < 0) {
      perror("send() error\n");
      return -1;
    } else if (rc == 0) {
      printf("send nothing !\n");
    } else {
      printf("send successfully!\n");
    }

    rc = recv(socketfd, buffer, sizeof(buffer), 0);
    if (rc < 0) {
      perror("recv() error\n");
      return -1;
    } else if (rc == 0) {
      printf("receive nothing\n");  
    } else {
      printf("receive %dth data: '%s'", i, buffer);
    }
    ++i;  

    sleep(2);
  }

  return 0;  
}

參考資料

• http://man7.org/linux/man-pages/man2/poll.2.html
• https://www.ibm.com/support/knowledgecenter/en/ssw_ibm_i_71/rzab6/poll.htm
• Linux高效能伺服器程式設計