原生API
select
int select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
函式引數
- numfds：檔案描述符的最大值＋1（為了限制檢測檔案描述符的範圍）
- readfds：包含所有因為狀態變為可讀而觸發select函式返回檔案描述符
- writefds：包含所有因為狀態變為可寫而觸發select函式返回檔案描述符
- exceptfds：包含所有因為狀態發生特殊異常而觸發select函式返回檔案描述符
- timeout：表示阻塞超時時限
返回值
- 當為-1的時候表示出錯
- 當為0的時候表示超時
- 當大於0則成功
// 新增fd到set中
FD_SET(int fd, fd_set *set);
// 從set中移除fd
FD_CLR(int fd, fd_set *set);
// 判斷fd是否在set中
FD_ISSET(int fd, fd_set *set);
// 將set整個清0
FD_ZERO(fd_set *set);
基本思路，把要檢測的檔案描述符載入到 fd_set 型別的集合中，然後呼叫 select 函式檢測載入到集合中的檔案描述符；
select 函式監視的檔案描述符分為3類，分別是 writefds, readfds, exceptfds，呼叫之後select函式就會阻塞，直到有檔案描述符就緒（有資料可讀，可寫或者except），或者超時（timeout指定等待時間，如果立即返回設為null即可），函式返回；當select函式返回之後，可以通過遍歷 fdset來找到就緒的描述符。
#include <iostream>
#include <sys/select.h>
#include <unistd.h>
#include <netinet/in.h>
#include <unistd.h>
#include <assert.h>
const int MAXSIZE = 1024;
int main() {
int sockfd = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); //sockfd為伺服器的套接字
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(4567); //1024 ~ 49151：普通使用者註冊的埠號
sin.sin_addr.s_addr = INADDR_ANY;
sockaddr_in client_addr;
// ...bind 和 listen操作
socklen_t clen = sizeof(sockaddr_in);
struct timeval tv;
int fds[MAXSIZE];
memset(fds,-1,sizeof(fds));
fd_set fdset;
fds[0] = sockfd;
while( 1 ) {
FD_ZERO(&fdset);
int i = 0;
int fdmax = fds[0];
for (; i < MAXSIZE; i++) {
if (fds[i] != -1) {
FD_SET(fds[i], &fdset);
if (fdmax < fds[i]) {
fdmax = fds[i];
}
}
}
tv.tv_sec = 2;
tv.tv_usec = 0;
int res = select(fdmax + 1, &fdset, NULL, NULL, &tv);
assert(res != -1);
if (res == 0) {
printf("timeout\n");
} else {
int i = 0;
for (; i < MAXSIZE; i++) {
if (fds[i] == -1) {
continue;
}
if (FD_ISSET(fds[i], &fdset)) {
if (fds[i] == sockfd) {
int c = accept(sockfd, (struct sockaddr *)&client_addr, &clen);
if (c >= 0) {
// 找到一個空的設定成新的套接字
for (int k = 0; k < MAXSIZE; k++) {
if (fds[i] == 0) {
fds[i] = c;
break;
}
}
}
} else {
char buff[256] = {0};
int n = read(fds[i], buff, 255);
if (n > 0) {
printf("read:%s\n", buff);
write(fds[i], "OK", 2);
} else if (n == 0) {
// 刪除套接字
fds[i] = 0;
}
}
}
}
}
}
}
這個程式碼中有不完善的地方：使用陣列儲存套接字，建議以連結串列的形式儲存連結串列會更好一些；
優點：跨平臺
缺點：
- 單個程序能夠監視的檔案描述符的數量存在最大限制，在Linux上一般為1024，可以通過修改巨集定義甚至重新編譯核心的方式提升這個限制，但是這樣也會造成效率的降低；
- 每次都要呼叫 select ，都需要把
fd集合從使用者態拷貝到核心態，在fd很多時開銷會很大； - 每次呼叫 select 都需要在核心遍歷傳遞進來的所有fd，在fd很多時開銷也很大；
注意，每次呼叫select之前都要對fdset集合進行 FD_ZERO(&fdset) 操作，即清空。
參考文章
linux的I/O複用技術
poll
int poll(struct pollfd *fds, unsigned int nfds, int timesout);
函式引數：
- 表示一個
pollfd結構的陣列。用來儲存想要監聽的檔案描述符及其註冊（繫結）的相應事件 - 表示監聽事件集合的大小
- 指定poll的超時值。當timeout為-1時，就會一直阻塞，直到某個事件發生；當timeout為0時，表示立即返回。
返回值：
當為-1的時候表示失敗，當為0的時候表示超時，當為大於0的整數的時候表示執行成功，表示檔案描述符的個數。
不同與select使用三個點陣圖來表示三個fdset的方式，poll使用一個 pollfd的指標實現。
struct pollfd {
int fd; /* file descriptor */
short events; /* requested events to watch */
short revents; /* returned events witnessed */
};
該結構裡包含了要監視等待的event和實際發生的event；
經常檢測的事件標記：
- POLLIN/POLLRDNORM：可讀
- POLLOUT/POLLWRNORM：可寫
- POLLERR：出錯
合法的事件標記如下：
- POLLIN： 有資料可讀
- POLLRDNORM： 有普通資料可讀
- POLLRDBAND： 有優先資料可讀
- POLLPRI： 有緊迫資料可讀
- POLLOUT： 寫資料不會導致阻塞
- POLLWRNORM： 寫普通資料不會導致阻塞
- POLLWRBAND： 寫優先資料不會導致阻塞
- POLLMSG SIGPOLL： 訊息可用
POLLIN | POLLPRI等價於select()的讀事件，POLLOUT |POLLWRBAND等價於select()的寫事件。POLLIN等價於POLLRDNORM |POLLRDBAND，而POLLOUT則等價於POLLWRNORM。
從原理上看，select 和 poll 都需要在返回以後，通過遍歷檔案描述符來獲取已經就緒的socket。但是和select不同的是，呼叫這個函式後，系統不用清空它所檢測的socket描述符集合；
因此select函式適合於只檢測少量socket描述符的情況，而poll函式適合於大量socket描述符的情況；
#include <unistd.h>
#include <sys/poll.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <poll.h>
#define OPEN_MAX 100
int main(int argc, char *argv[])
{
//1.建立tcp監聽套接字
int sockfd = ::socket(AF_INET, SOCK_STREAM, 0);
//2.繫結sockfd
struct sockaddr_in my_addr;
bzero(&my_addr, sizeof(my_addr));
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(8000);
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
bind(sockfd, (struct sockaddr *)&my_addr, sizeof(my_addr));
//3.監聽listen
listen(sockfd, 10);
//4.poll相應引數準備
struct pollfd client[OPEN_MAX];
int i = 0, maxi = 0;
for(;i<OPEN_MAX; i++)
client[i].fd = -1;//初始化poll結構中的檔案描述符fd
client[0].fd = sockfd;//需要監測的描述符
client[0].events = POLLIN;//普通或優先順序帶資料可讀
//5.對已連線的客戶端的資料處理
while(1)
{
int ret = ::poll(client, maxi+1, -1);//對加入poll結構體陣列所有元素進行監測
if (ret == -1) {
cout << "poll failed" << endl;
continue;
}
//5.1監測sockfd(監聽套接字)是否存在連線
if((client[0].revents & POLLIN) == POLLIN )
{
struct sockaddr_in cli_addr;
int clilen = sizeof(cli_addr);
int connfd = 0;
//5.1.1 從tcp完成連線中提取客戶端
connfd = ::accept(sockfd, (struct sockaddr *)&cli_addr, &clilen);
//5.1.2 將提取到的connfd放入poll結構體陣列中，以便於poll函式監測
for(i=1; i<OPEN_MAX; i++)
{
if(client[i].fd < 0)
{
client[i].fd = connfd;
client[i].events = POLLIN;
break;
}
}
//5.1.3 maxi更新
if(i > maxi)
maxi = i;
}
//5.2繼續響應就緒的描述符
for(i=1; i<=maxi; i++)
{
if(client[i].fd < 0)
continue;
if(client[i].revents & (POLLIN | POLLERR))
{
int len = 0;
char buf[128] = "";
//5.2.1接受客戶端資料
if((len = recv(client[i].fd, buf, sizeof(buf), 0)) < 0)
{
if(errno == ECONNRESET)//tcp連線超時、RST
{
close(client[i].fd);
client[i].fd = -1;
}
else
cout << "read error:" << endl;
}
else if(len == 0)//客戶端關閉連線
{
close(client[i].fd);
client[i].fd = -1;
}
else {//正常接收到伺服器的資料
::send(client[i].fd, buf, len, 0);
}
//5.2.2所有的就緒描述符處理完了，就退出當前的for迴圈，繼續poll監測
if(--ret <= 0)
break;
}
}
}
}
kqueue
int kqueue(void);
生成一個核心事件佇列，返回該佇列的檔案描述符，其它API通過這個描述符操作這個 kqueue，結構如下：
struct kevent {
uintptr_t ident; //事件ID，一般為檔案描述符
short filter; //事件過濾器
u_short flags; //行為標示
u_int fflags; //過濾器標識值
intptr_t data; //過濾器資料
void *udata; //應用透傳資料
};
int kevent(int kq, const struct kevent *changelist, int nchanges, struct kevent *eventlist, int nevents, const struct timespec *timeout);
提供向核心註冊／反註冊事件和返回就緒事件或錯誤事件；在一個kqueue中，｛ident，filter｝確定一個唯一的事件；
函式引數：
- kq：kqueue的檔案描述符
- changelist：註冊／反註冊的事件陣列
- nchanges：changelist的元素個數
- eventlist：滿足條件的通知事件陣列
- nevents：eventlist的元素個數
- timeout：等待事件到來時的超時時間
返回值為可用事件的個數
kqueue不光能夠處理socket的事件，同時還能處理非同步io，訊號，檔案變化等等；
kqueue有兩個部分，分別是kqueue和kevent；kqueue主要是用來描述event的佇列，而kevent則是監聽的事件；
通過kevent提供三個主要的行為功能，分別是
註冊／反註冊
注意
kevent中的neventlist這個輸入引數，當其設為0，且傳入合法的changelist和nchanges，就會將changelist中的事件註冊到 kqueue 中；允許／禁止過濾器事件
通過
flags EV_ENABLE 和 EV_DISABLE使過濾器事件有效或者無效，這個功能在使用EVFILT_WRITE傳送資料時非常有用；等待事件通知
將
nchangelist 和 nchanges設定成null和0，當kevent非錯誤和超時返回時，在eventlist和nevents中儲存可用事件集合。
實現
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/event.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#define PORT 5001
#define MAX_EVENT_COUNT 64
int createSocket()
{
int sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == -1)
{
printf("socket() failed:%d\n",errno);
return -1;
}
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(PORT);
addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
int optval = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
optval = 1;
setsockopt(sock, SOL_SOCKET, SO_NOSIGPIPE, &optval, sizeof(optval));
if (bind(sock, (struct sockaddr*)&addr, sizeof(struct sockaddr)) == -1)
{
printf("bind() failed:%d\n",errno);
return -1;
}
if (listen(sock, 5) == -1)
{
printf("listen() failed:%d\n",errno);
return -1;
}
return sock;
}
int main(int argc, const char * argv[])
{
int listenfd = createSocket();
if (listenfd == -1)
return -1;
int kq = kqueue();
if (kq == -1)
{
printf("kqueue failed:%d",errno);
return -1;
}
struct kevent event = {listenfd,EVFILT_READ,EV_ADD,0,0,NULL};
int ret = kevent(kq, &event, 1, NULL, 0, NULL);
if (ret == -1)
{
printf("kevent failed:%d",errno);
return -1;
}
while (true)
{
struct kevent eventlist[MAX_EVENT_COUNT];
struct timespec timeout = {5,0};
int ret = kevent(kq, NULL, 0, eventlist, MAX_EVENT_COUNT, &timeout);
if (ret <= 0)
continue;
for (int i=0; i<ret; i++)
{
struct kevent event = eventlist[i];
int sock = (int)event.ident;
int16_t filter = event.filter;
uint32_t flags = event.flags;
intptr_t data = event.data;
//有新的客戶端連結
if (sock == listenfd)
{
socklen_t client_addrlen = 4;
struct sockaddr client_addrlist[client_addrlen];
int clientfd = accept(listenfd, client_addrlist, &client_addrlen);
if (clientfd > 0)
{
struct kevent changelist[2];
EV_SET(&changelist[0], clientfd, EVFILT_READ, EV_ADD, 0, 0, NULL);
EV_SET(&changelist[1], clientfd, EVFILT_WRITE, EV_ADD, 0, 0, NULL);
kevent(kq, changelist, 1, NULL, 0, NULL);
}
continue;
}
//異常事件
if (flags & EV_ERROR)
{
close(sock);
struct kevent event = {sock,EVFILT_READ,EV_DELETE,0,0,NULL};
kevent(kq, &event, 1, NULL, 0, NULL);
printf("socket broken,error:%ld\n",data);
continue;
}
//資料可讀
if (filter == EVFILT_READ)
{
char buffer[data];
memset(buffer, '\0', data);
ssize_t recvlen = recv(sock, buffer, data, 0);
if (recvlen <= 0)
{
//連結斷開
close(sock);
struct kevent event = {sock,EVFILT_READ,EV_DELETE,0,0,NULL};
kevent(kq, &event, 1, NULL, 0, NULL);
printf("socket broken!\n");
continue;
}
printf("%s\n",buffer);
}
//資料可寫
if (filter == EVFILT_WRITE)
{
char buffer[data];
memset(buffer, 'a', data);
ssize_t sendlen = send(sock, buffer, data, 0);
if (sendlen <= 0)
{
//連結斷開
close(sock);
struct kevent event = {sock,EVFILT_READ,EV_DELETE,0,0,NULL};
kevent(kq, &event, 1, NULL, 0, NULL);
printf("socket broken!\n");
continue;
}
}
}
}
return 0;
}
不同
和前面不同的是，kqueue不會像select或者poll一樣每隔一段事件就去輪詢所有的socket，當socket數量很多，但是很多socket都不活躍的時候，效能是有影響的，而kqueue只會關注事件發生的socket；
epoll
函式
- 建立事件表
int epoll_create(int size);
建立一個epoll的控制代碼，引數 size 並不是限制了epoll所能監聽的描述符最大個數，只是對核心初始分配內部資料結構的建議，不同於select中的給出最大監聽的fd+1。
- 操作事件表
int epoll_ctl(int epfd, int op, int fd, struct epoll_event* event);
函式引數
epfd：事件表的檔案描述符
op：何種操作，包括
EPOLL_CTL_ADD，EPOLL_CTL_DEL，EPOLL_CTL_MOD，分別實現對fd的監聽事件進行新增、刪除、修改fd：需要監聽的檔案描述符
event：告訴核心需要監聽什麼事
epoll_event 結構如下：
struct epoll_event {
__uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
}; //events可以是以下幾個巨集的集合：
EPOLLIN ：表示對應的檔案描述符可以讀（包括對端SOCKET正常關閉）；
EPOLLOUT：表示對應的檔案描述符可以寫；
EPOLLPRI：表示對應的檔案描述符有緊急的資料可讀（這裡應該表示有帶外資料到來）；
EPOLLERR：表示對應的檔案描述符發生錯誤；
EPOLLHUP：表示對應的檔案描述符被結束通話；
EPOLLET： 將EPOLL設為邊緣觸發(Edge Triggered)模式，這是相對於水平觸發(Level Triggered)來說的。
EPOLLONESHOT：只監聽一次事件，當監聽完這次事件之後，如果還需要繼續監聽這個socket的話，需要再次把這個socket加入到EPOLL佇列裡
- 監聽相應事件
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
函式引數：
- epfd：事件表的檔案描述符
- events：從核心得到事件的集合
- maxevents：事件集合的大小（不能大於建立時的
size） - timeout：超時時間
工作模式
epoll對檔案描述符的操作有兩種模式：LT（level trigger）和ET（edge trigger）。LT模式是預設模式，LT模式與ET模式的區別如下：
LT模式：當epoll_wait檢測到描述符事件發生並將此事件通知應用程式，應用程式可以不立即處理該事件。下次呼叫epoll_wait時，會再次響應應用程式並通知此事件。
ET模式：當epoll_wait檢測到描述符事件發生並將此事件通知應用程式，應用程式必須立即處理該事件。如果不處理，下次呼叫epoll_wait時，不會再次響應應用程式並通知此事件。
ET模式在很大程度上減少了epoll事件被重複觸發的次數，因此效率要比LT模式高。epoll工作在ET模式的時候，必須使用非阻塞套介面，以避免由於一個檔案控制代碼的阻塞讀/阻塞寫操作把處理多個檔案描述符的任務餓死。
當使用epoll的ET模型來工作時，當產生了一個EPOLLIN事件後， 讀資料的時候需要考慮的是當recv()返回的大小如果等於請求的大小，那麼很有可能是緩衝區還有資料未讀完，也意味著該次事件還沒有處理完，所以還需要再次讀取：
void handle_rev() {
while(rs){
buflen = ::recv(activeevents[i].data.fd, buf, sizeof(buf), 0);
if(buflen < 0){
// 由於是非阻塞的模式,所以當errno為EAGAIN時,表示當前緩衝區已無資料可讀
// 在這裡就當作是該次事件已處理處.
if(errno == EAGAIN){ //EAGAIN經常出現在當應用程式進行一些非阻塞(non-blocking)操作(對檔案或socket)的時候
break;
}
else{
return;
}
}
else if(buflen == 0){
// 這裡表示對端的socket已正常關閉.
}
if(buflen == sizeof(buf){
rs = 1; // 需要再次讀取
}
else{
rs = 0;
}
}
}
有時候epoll不一定比select和poll的效率高，比如這樣的場景下：當活動連線數比較高的時候此時epoll會經常觸發回撥函式 ，此時在效能上還是有一定的損失．epoll適用於連線數量多，但是活躍的連線少．
實現
epollserver::epollserver(int af, int type, int protocol) : norserver(af, type, protocol) {
this->_epollfd = ::epoll_create(MAX_SIZE);
if (this->_epollfd == INVALID_SOCKTE) {
cout << "epoll create failed" << endl;
}
}
epollserver::~epollserver() {
this->close(this->socket());
}
void epollserver::wait_events() {
struct epoll_event _events[EPOLL_EVENTS_NUM];
this->add_event(this->socket(), EPOLLIN);
while (true) {
int ret = ::epoll_wait(this->_epollfd, _events, EPOLLEVENTS, -1);
this->handle_events(_events, ret);
}
}
void epollserver::handle_events(struct epoll_event* events, int num) {
for (int i = 0; i < num; i++) {
int socket = events[i].data.fd;
// 伺服器本身
if (socket == this->socket()) {
this->handle_accept();
}
else if (events[i].events & EPOLLIN) {
this->handle_read(socket);
}
else if (events[i].events & EPOLLOUT) {
this->handle_write(socket);
}
}
}
void epollserver::handle_accept() {
this->accept();
}
void epollserver::handle_read(int socket) {
int nread;
char buf[MAX_SIZE];
nread = ::read(socket, buf, MAX_SIZE);
if (nread == SOCKET_ERROR) {
cout << "read error:" << endl;
this->close(socket); //記住close fd
delete_event(socket, EPOLLIN); //刪除監聽
}
else if (nread == 0) {
fprintf(stderr,"client close.\n");
this->close(socket); //記住close fd
delete_event(socket, EPOLLIN); //刪除監聽
}
else {
cout << "read message is :" << buf;
//修改描述符對應的事件，由讀改為寫
modify_event(socket, EPOLLOUT);
}
}
void epollserver::handle_write(int socket) {
int nwrite;
char buf[MAX_SIZE];
nwrite = ::write(socket, buf, strlen(buf));
if (nwrite == -1){
cout << "write error:" << endl;
this->close(socket); //記住close fd
delete_event(socket, EPOLLOUT); //刪除監聽
}else{
modify_event(socket, EPOLLIN);
}
memset(buf,0, MAX_SIZE);
}
bool epollserver::add_event(int socket, int state) {
struct epoll_event ev;
ev.events = state;
ev.data.fd = socket;
if (!epoll_ctl(this->_epollfd, EPOLL_CTL_ADD, socket, fd, &ev)) {
cout << "epoll add event failed" << endl;
return false;
}
return true;
}
bool epollserver::delete_event(int socket, int state) {
struct epoll_event ev;
ev.events = state;
ev.data.fd = socket;
if (!epoll_ctl(this->_epollfd, EPOLL_CTL_DEL, socket, fd, &ev)) {
cout << "epoll delete event failed" << endl;
return false;
}
return true;
}
bool epollserver::modify_event(int socket, int state) {
struct epoll_event ev;
ev.events = state;
ev.data.fd = socket;
if (!epoll_ctl(this->_epollfd, EPOLL_CTL_MOD, socket, fd, &ev)) {
cout << "epoll modify event failed" << endl;
return false;
}
return true;
}