day02 真正的高併發還得看IO多路複用

會玩code發表於2022-04-27

教程說明

C++高效能網路服務保姆級教程

首發地址

day02 真正的高併發還得看IO多路複用

本節目的

使用epoll實現一個高併發的伺服器

從單程式講起

上節從一個基礎的socket服務說起我們實現了一個基本的socket伺服器，並留了個思考題

先啟動server，然後啟動一個client，不輸入資料，這個時候在另外一個終端上再啟動一個client，並在第二個client終端中輸入資料，會發生什麼呢？

實際操作後，我們會發現，在第二個client輸入後，服務端並沒有響應，直到第一個client也輸入資料完成互動後，第二個client才會有資料返回。

這是由於服務端accept獲取到第一個client的套接字後，由於第一個client未輸入資料，所以服務端程式會阻塞在等待客戶端資料那一行。

...
int read_num = read(accept_fd, read_msg, 100);
...

所以，第二個client完成三次握手後，連線一直在服務端的全連線佇列中，等待accept獲取處理。

多執行緒，一個執行緒一個連線

後續的client無法得到處理是由於服務端只有一個執行緒，獲取client套接字還有連線通訊全在一個執行緒中。

那我們直接開多個執行緒就好了，主執行緒只負責accept獲取客戶端套接字。每來一個連線，我們就新起一個執行緒去處理客戶端和服務端的通訊。這樣多個連線之間就不會互相影響了。服務端程式如下：

// per_conn_per_thread_server.cpp
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <thread>
#include <arpa/inet.h>
#include <string.h>
#include <cstdio>
#include <errno.h>

void handleConn(int accept_fd) {
  char read_msg[100];
  int read_num = read(accept_fd, read_msg, 100);
  printf("get msg from client: %s\n", read_msg);
  int write_num = write(accept_fd, read_msg, read_num);
  close(accept_fd);
}

int main() {
  int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
  struct sockaddr_in server_addr;
  bzero(&server_addr, sizeof(server_addr));
  server_addr.sin_family = AF_INET;
  server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  server_addr.sin_port = htons(8888);
  if (bind(listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
    printf("bind err: %s\n", strerror(errno));
    close(listen_fd);
    return -1;
  }

  if (listen(listen_fd, 2048) < 0) {
    printf("listen err: %s\n", strerror(errno));
    close(listen_fd);
    return -1;
  }
  
  struct sockaddr_in client_addr;
  bzero(&client_addr, sizeof(struct sockaddr_in));
  socklen_t client_addr_len = sizeof(client_addr);
  int accept_fd = 0;
  while((accept_fd = accept(listen_fd, (struct sockaddr *)&client_addr, &client_addr_len)) > 0) {
    printf("get accept_fd: %d from: %s:%d\n", accept_fd, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    std::thread handleThread(handleConn, accept_fd);
    // 將執行緒設定為後臺執行緒，避免阻塞主執行緒
    handleThread.detach();
  }
}

使用thread庫時，如果使用g++進行編譯需要新增-lpthread,完整編譯命令：

g++ -std=c++11 xxx.cpp -lpthread

看似解決阻塞問題了，但其實這種方案有大缺陷，只要我們稍微加大下客戶端的併發度，就會發現服務端會處理不過來。每來一個連線都建立一個新執行緒，處理完後再銷燬執行緒，這種處理方式成本太大。

IO多路複用和Reactor模型

我們仔細分析下，「per connection per thread」出現效能瓶頸有以下幾個原因：

  1. 一個系統能同時建立的執行緒數量是有限的，而且執行緒數量越多，佔用記憶體也會變多，容易導致OOM。
  2. 每個連線都用一個新執行緒去處理，處理結束後銷燬對應執行緒，執行緒建立和銷燬都需要較大開銷。
  3. 一個執行緒當執行時間片用完或者遇到系統呼叫阻塞時，都會讓出CPU。CPU會保留執行緒的現場資訊，然後去執行其他執行緒（這個過程也稱為CPU上下文切換）。所以當執行緒數很多時，CPU的執行緒上下文切換也會越頻繁，真正用於處理連線通訊的時間也會越少。也就是CPU在瞎忙活。

既然是由於併發量高時執行緒太多導致的效能問題，那如果有一種技術，能讓一個執行緒負責N個連線就能完美解決了。虛擬碼如下：

class HandleThread {
    std::vector<int> handle_fds;
    void addFd(int fd) {handle_fds.push_back(fd)};
    void work();
}
HandleThread::work() {
    for(;;) {
        int readyFd = getReadyIOFd();
        ...
        // 對readyFd讀寫處理
        ...
    }
}

auto pool = createThreadPool(4);
int accept_fd = accept(...);
HandleThread thread = pool.getThread();
thread.addFd(accept_fd);

上面程式碼大家應該很容易看懂，先建立一個指定執行緒數量的執行緒池，主執行緒獲取到新連線後，丟到執行緒池的一個執行緒去處理。每個執行緒初始化後會執行work函式，work函式是一個while死迴圈，裡面的getReadyIOFd會阻塞執行緒，直到有可讀可寫的套接字時，才會喚醒執行緒，去進行連線的讀寫。

掃盲點：一般我們講的由於系統呼叫（比如read/write等）導致阻塞，這個時候阻塞的執行緒狀態會被置為掛起，不會佔用CPU。所以上面雖然有個while死迴圈，但在getReadyIOFd被阻塞了，getReadyIOFd底層也是個系統呼叫（具體實現我們後面會講到），在沒有可讀寫的套接字時執行緒並不會佔用CPU。

上面的流程，其實就是大名鼎鼎的IO多路複用和Reactor多執行緒模型了。

epoll登場

這一節我們具體聊聊一個handleThread是如何管理多個套接字的。

IO多路複用的實現模型大家多少聽過一些，我們先比較下常見的select和epoll

select

select簡單理解就是拿一個陣列儲存連線套接字，呼叫select時，會將整個陣列拷貝到核心空間中，如果當前陣列中沒有可讀寫的套接字，執行緒被阻塞。

等到陣列中有可讀寫的套接字，或者超時（select可以設定阻塞的超時時間），select呼叫會返回，然後執行緒遍歷全部陣列，找到可讀寫的套接字，進行讀寫處理。

select存在以下幾個缺點：

  1. 陣列中的套接字數量有限制。最多1024個，這個數是select程式碼中寫死的，具體可看/usr/include/bits/typesizes.h中有定義。
  2. select返回後，只是告訴我們這些陣列中有fd就緒了，但卻沒告訴我們具體是哪個fd可讀寫，我們需要輪訓整個資料，才能找到可操作的fd。效率比較低
  3. 需要維護一個用來存放大量fd的資料結構，這樣會使得使用者空間和核心空間在傳遞該結構時複製開銷大。

epoll

epoll是linux2.6的時候提出的，epoll在核心中維護了一個eventpoll物件，eventpoll包含一個紅黑樹結構的等待佇列wq和一個連結串列結構的就緒佇列rdlist。

新獲取到一個套接字後，將該套接字新增到wq中，等到套接字可讀寫時，作業系統會將該套接字從wq轉到rdlist，然後執行緒直接處理rdlist中的套接字即可，不需要再遍歷全部監聽的套接字了。

與select相比，可以發現有以下幾個優點：

  1. 沒有套接字數量的限制
  2. 阻塞返回後，會明確告知哪些套接字是可以讀寫的，不需要全部輪訓，效率較高

epoll基本使用

因為我們的專案選用epoll，所以下面我們具體講講epoll的使用方法

  1. epoll_create建立一個epoll例項
int epoll_create(int size);
int epoll_create1(int flags);
  • size：用來告知核心期望監控的套接字數量，但在2.6.8之後就廢棄了，由系統自動化分配。
  • flags: 如果設定為0，和epoll_create功能相同。可以設定為EPOLL_CLOEXEC, 表示當持有epoll控制程式碼的程式fork出一個子程式時，子程式不會包含該epoll_fd。
  • 返回值：成功返回epoll_fd,失敗返回-1
  1. epoll_ctl管理監聽的描述符，並註冊要監聽的事件
int epoll_ctl(int epfd, int op, int fd, struct epoll_event* event);
  • epfd: epoll_create建立的epoll_fd
  • op: 要操作的型別：
    a. EPOLL_CTL_ADD ：註冊事件
    b. EPOLL_CTL_MOD：更改事件
    c. EPOLL_CTL_DEL：刪除事件
  • fd: 要操作的檔案描述符
  • event: 要註冊的事件型別
typedef union epoll_data
{
  void *ptr;
  int fd;
  uint32_t u32;
  uint64_t u64;
} epoll_data_t;

struct epoll_event
{
  uint32_t events;	/* Epoll events */
  epoll_data_t data;	/* User data variable */
}

// epoll_event.event表示具體的事件型別，常見有以下幾種：
// EPOLLIN：檔案描述符可讀
// EPOLLOUT：檔案描述符可寫
// EPOLLRDHUP：套接字對端斷開
// EPOLLET：邊緣觸發（後面細講）
  1. epoll_wait 等待事件發生，沒有事件時，呼叫者程式會被掛起，等到事件發生/超時後返回
int epoll_wait(int epfd, struct epoll_event* evlist, int maxevents, int timeout);
  • epfd: epoll_create建立的epoll_fd
  • evlist: 返回給使用者空間的可以處理的IO事件陣列，即前面說的就緒佇列
  • maxevents：表示一次epoll_wait最多可以返回的事件數量
  • timeout： epoll_wait阻塞的超時值，如果設定為-1，表示不超時，如果設定為0，即使沒有IO事件也會立即返回

epoll有EPOLLLT(水平觸發)和EPOLLET(邊緣觸發)兩種工作模式：

  • 水平觸發：只要socket處於可讀狀態(緩衝區有資料)或可寫狀態，無論什麼時候進行epoll_wait都會返回該socket，也就是說我們第一次epoll_wait返回後讀了部分資料，在下一次的epoll_wait呼叫還是會返回之前那個沒讀完資料的socket。
  • 邊緣觸發：只有套接字的狀態由不可寫到可寫或由不可讀到可讀時，才會觸發epoll_wait返回。如果我們第一次epoll_wait返回中讀了部分資料，如果該套接字沒再收到新資料，那即使該套接字快取區中還有一些資料沒讀，下一次的epoll_wait也不會返回該套接字了。所以我們需要在第一次讀時通過迴圈read的方式把套接字中的資料全讀出來。

邊緣觸發處理起來會比水平觸發比較麻煩，但效能會比水平觸發高，因為減少 epoll 相關係統呼叫次數

講完epoll的使用方法，我們把前面的虛擬碼套上epoll的邊緣觸發模式，完整程式碼如下：

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <thread>
#include <arpa/inet.h>
#include <string.h>
#include <cstdio>
#include <errno.h>
#include <vector>
#include <assert.h>
#include <sys/epoll.h>
#include <fcntl.h>

int setfdNonBlock(int fd) {
  int flag = fcntl(fd, F_GETFL, 0);
  if (flag == -1) return -1;
  flag |= O_NONBLOCK;
  if (fcntl(fd, F_SETFL, flag) == -1) return -1;
  return 0;
};

void handleConn(int accept_fd) {
  char read_msg[100];
  char *buf_ptr = read_msg;
  int total_read_num = 0;
  int read_num = 0;
  // 使用的是epollet邊緣觸發模式，需要把套接字快取區中的資料全讀完
  do {
    read_num = read(accept_fd, buf_ptr, 100);
    buf_ptr += read_num;
    total_read_num += read_num;
  } while(read_num > 0);
  printf("get msg from client: %s\n", read_msg);
  int write_num = write(accept_fd, read_msg, total_read_num);
  close(accept_fd);
}

int listenServer(char *host, int port) {
  int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
  struct sockaddr_in server_addr;
  bzero(&server_addr, sizeof(server_addr));
  server_addr.sin_family = AF_INET;
  server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  server_addr.sin_port = htons(8888);
  if (bind(listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
    printf("bind err: %s\n", strerror(errno));
    close(listen_fd);
    return -1;
  }

  if (listen(listen_fd, 2048) < 0) {
    printf("listen err: %s\n", strerror(errno));
    close(listen_fd);
    return -1;
  }
  return listen_fd;
}

const int EPOLLWAIT_TIME = 10000;
const int EVENTSMAXNUM = 4096;

class HandleThread {
  public:
    HandleThread() 
    : epoll_fd_(epoll_create1(EPOLL_CLOEXEC)),
      epoll_events_(EVENTSMAXNUM),
      thread_(std::bind(&HandleThread::work, this)) {
      assert(epoll_fd_ > 0);
      thread_.detach();
    }
    ~HandleThread() {
      close(epoll_fd_);
    }
    // 執行緒實際執行函式
    void work();
    // 新增監聽套接字
    void addFd(int fd);
    // 不再監聽指定套接字
    void rmFd(int fd);
  private:
    int epoll_fd_;
    std::vector<epoll_event>epoll_events_;
    std::thread thread_;
};

void HandleThread::work() {
  for(;;) {
    int event_count = epoll_wait(epoll_fd_, &*epoll_events_.begin(), epoll_events_.size(), EPOLLWAIT_TIME);
    if (event_count < 0) {
      perror("epoll wait error");
      continue;
    }
    for (int i = 0; i < event_count; i++) {
      epoll_event cur_event = epoll_events_[i];
      int fd = cur_event.data.fd;

      // 不再監聽fd，從epoll中去掉
      rmFd(fd);
      // 處理連線讀寫
      handleConn(fd);
    }
  }
}

void HandleThread::addFd(int fd) {
  epoll_event event;
  event.data.fd = fd;
  // 只監聽讀事件
  event.events = EPOLLIN | EPOLLET;
  if (epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &event) < 0) {
    perror("epoll_add error");
  }
}

void HandleThread::rmFd(int fd) {
  epoll_event event;
  event.data.fd = fd;
  event.events = EPOLLIN | EPOLLET;
  if (epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, &event) < 0) {
    perror("epoll_del error");
  }
}

typedef std::shared_ptr<HandleThread> SP_HandleThread;

class HandleThreadPool {
  public:
    HandleThreadPool(int thread_nums) : thread_nums_(thread_nums), next_thread_idx_(0) {
      for (int i = 0; i < thread_nums; i++) {
        SP_HandleThread t (new HandleThread());
        thread_pool_.push_back(t);
      }
    }
    SP_HandleThread getThread();
  private:
    int thread_nums_;
    int next_thread_idx_;
    std::vector<SP_HandleThread> thread_pool_;
};

// 從執行緒池中獲取一個執行緒
SP_HandleThread HandleThreadPool::getThread() {
  SP_HandleThread t = thread_pool_[next_thread_idx_];
  next_thread_idx_ = (next_thread_idx_ + 1) % thread_nums_;
  return t;
}

int main() {
  int listen_fd = listenServer("127.0.0.1", 8888);

  // 建立執行緒池
  HandleThreadPool pool(4);
  // 等待1秒
  sleep(1);
  struct sockaddr_in client_addr;
  bzero(&client_addr, sizeof(struct sockaddr_in));
  socklen_t client_addr_len = sizeof(client_addr);
  int accept_fd = 0;
  while((accept_fd = accept(listen_fd, (struct sockaddr *)&client_addr, &client_addr_len)) > 0) {
    printf("get accept_fd: %d from: %s:%d\n", accept_fd, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
    // 將fd設定為非阻塞 ?
    setfdNonBlock(accept_fd);
    // 從pool中獲取一個執行緒處理連線
    SP_HandleThread t = pool.getThread();
    t->addFd(accept_fd);
  }
}

程式碼比較長，但不難，大家可以fork下來慢慢看。

使用了智慧指標，避免忘記回收堆上的資源。

大家可能會發現程式碼有兩次註釋新增了"?"，第一處是在建立執行緒池後，sleep了1秒，這個當成本節的思考題，大家可以先思考，並想想有沒有什麼更好的解決辦法？

第二處是在獲取到accept_fd後，將fd設定為非阻塞了。下面我們展開具體講講。

非阻塞與IO多路複用更搭

首先我們先聊聊阻塞IO呼叫和非阻塞IO呼叫的區別。

阻塞IO呼叫：程式在呼叫IO操作時，如果沒有資料可讀或緩衝區沒有空閒空間可寫，導致IO操作未完成，程式被阻塞掛起，後續操作將無法執行。比如下面程式碼，如果客戶端建立連線後，一直不傳送資料，那服務端執行就會阻塞在read呼叫，後面的printf無法被執行到。

int accept_fd = accept(...);
char read_msg[100];
int read_num = read(accept_fd, read_msg, 100);
printf("i am a log\n");

小提示：上面的程式碼即使客戶端只發了1個位元組的資料，服務端read呼叫也會返回，並不是要等到讀滿100個位元組才會返回。

非阻塞IO呼叫: 程式在呼叫IO操作時，即使IO操作未完成，該IO呼叫也會立刻返回，之後程式可以進行後續操作。比如下面程式碼，將accept_fd設定為非阻塞後，再呼叫read，這時即使客戶端沒有發資料，服務端也不會一直卡在read呼叫上，後面的printf能順利列印出來。

int accept_fd = accept(...);
// 將fd設定為非阻塞
setfdNonBlock(accept_fd);
char read_msg[100];
int read_num = read(accept_fd, read_msg, 100);
printf("i am a log\n");

下面我們再說下為什麼IO多路複用要搭配非阻塞IO？

在前面，我們使用epoll實現了一個執行緒管理多個套接字，當某個套接字有讀寫事件時，epoll_wait呼叫返回，告訴我們哪些套接字能讀，但並不會告訴我們某個套接字上有多少資料可讀。

  • 使用非阻塞IO處理方式：我們只要迴圈的read，直到讀完全部的資料即可（read返回0）。
  • 使用阻塞IO處理方式：每次只能呼叫一次read，因為我們並不知道下一次迴圈中還有沒有資料可讀，如果沒資料就會阻塞整個程式了，所以只能等待下一次的epoll_wait返回了。這對於水平觸發還可行，但對於邊緣觸發就不行了，因為我們不知道這個套接字還會不會有新資料寫入，如果對端不再寫入新資料，那緩衝區中剩下的資料就再也讀不到了。

完整原始碼已上傳到https://github.com/lzs123/CProxy-tutorial,歡迎fork and star！

參考文章

如果這篇文章說不清epoll的本質，那就過來掐死我吧！

寫在最後

如果本文對你有用，點個贊再走吧！或者關注我，我會帶來更多優質的內容。

相關文章