在Linux環境下select函數的初體驗

作者：Lin_R 2017-03-08 15:39:11

在linux中, 主要的 IO復用方式中, 有epoll, poll 和select, 這次先來學習下select。select 能夠同時監視多個文件描述符的變法, 也支持超時返回。

select介紹

在linux中, 主要的 IO復用方式中, 有epoll, poll 和select, 這次先來學習下select.

select 能夠同時監視多個文件描述符的變法, 也支持超時返回.

先來看下select函數的定義

/* /usr/include/sys/select.h */ 
extern int select (int __nfds,               // 最大文件描述符+1 
           fd_set *__restrict __readfds,     // 讀狀態文件集 
           fd_set *__restrict __writefds,    // 寫狀態文件集 
           fd_set *__restrict __exceptfds,   // 異常狀態文件集 
           struct timeval *__restrict __timeout);  // 超時時間

如上圖函數聲明所示, 不管我們關注什么狀態, 我們都應該把同一類狀態的文件描述符存到同一個fd_set集合,以便select能夠相應的位置打上標簽, 以便后續我們來判斷該文件描述符是否已經準備好

這些傳遞給select函數的參數, 將告訴內核:

我們需要監聽的文件描述符
對于每個文件描述符, 我們所關心的狀態 (讀/寫/異常)
我們要等待多長時間 (無限長/超時返回)

而內核也會通過select的返回, 告知我們一些信息:

已經準備好的文件描述符個數
那三種狀態分別是哪些文件描述符

我們可以通過以下方式將關注的文件描述符加入相應的文件集:

int socket_test; 
socket_test = socket(...);      //創建socket文件描述符 
connent(socket_test,..);        //連接服務端 
FD_SET(socket_test, &rdfds);    //加入讀狀態文件集 
FD_SET(socket_test, &wdfds);    //加入寫狀態文件集 
....

select原理

select函數執行順序是: SYSCALL_DEFINE5 (sys_select) -> core_sys_select -> do_select

我們都知道, select 支持監聽三個文件集: 讀文件集, 寫文件集, 異常文件集;

在我們調用FD_SET(socket_test, &rdfds)時, 實際上執行的操作是: 在rdfds成員數組中, 將__FDELT (d)位置的值設成 __FDMASK (d), 直接說會有點疑惑, 先看下相關的函數,宏定義是怎樣定義的吧:

/* 取自: /usr/include/sys/select.h */ 
#define FD_SET(fd, fdsetp)  __FD_SET (fd, fdsetp) 
typedef long int __fd_mask; 
 
/* 取自: /usr/include/bits/select.h  */ 
 
#define __NFDBITS   (8 * (int) sizeof (__fd_mask)) 
#define __FDELT(d)  ((d) / __NFDBITS) 
#define __FDMASK(d) ((__fd_mask) 1 << ((d) % __NFDBITS)) 
 
#define __FD_SET(d, set)    (__FDS_BITS (set)[__FDELT (d)] |= __FDMASK (d)) 
 
typedef struct 
  { 
    /* XPG4.2 requires this member name.  Otherwise avoid the name 
       from the global namespace.  */ 
#ifdef __USE_XOPEN 
    __fd_mask fds_bits[__FD_SETSIZE / __NFDBITS]; 
# define __FDS_BITS(set) ((set)->fds_bits) 
#else 
    __fd_mask __fds_bits[__FD_SETSIZE / __NFDBITS]; 
# define __FDS_BITS(set) ((set)->__fds_bits) 
#endif 
  } fd_set; 
 
/* /usr/include/linux/posix_types.h */ 
#define __FD_SETSIZE    1024

舉個栗子, 假設 fd=3, 當我們執行FD_SET(fd, &rdfds)時:

算出 __FDELT(d) 和 __FDMASK(d)的值, 通過上面的宏定義, 可以分別得出結果: 3/(8*8), 1<<3%(8*8), 也就是0 和二進制的 0000 0100
然后分別將值存入 rdfds.__fds_bits第0個位置, 值為十進制的8
我們可以將__fds_bit的每個索引看成是一個聚合的過程, 每個值8字節, 也就是有64位, 可以存64個fd, 在我的系統上, 算出數組的長度是__FD_SETSIZE / __NFDBITS = 1024/8=128個, 也就是大概能容納 128*64=8192(如果理解錯誤請指出)

經過上面的運算, 我們將需要關注的文件描述關聯到 rdfds文件集了, 對于寫文件集, 異常文件集都是同樣的運算, 等這些步驟都進行完了, 接下來就是進入core_sys_select函數了:

執行到 core_sys_select 時, 定義一個fd_set_bits結構體: fds.
分別為fds的成員(in, out, ex, res_in, res_out, res_ex)申請內存
將我們傳給select的 rdfds, wrfds, exfds分別賦值給 in, out, ex, 這樣fds就能記錄三個集合的結果了
初始化那個三個成員之后, 將執行do_select(n, &fds, end_time)
在do_select中, 函數將進入死循環,其中還有兩個循環, 分別是針對 "最大文件描述符數" 和 fd_set_bits數組中單個值位數. 從上面我們已經知道, 在fd_set_bits每個值都代表所關注的文件描述符, 每個值是__NFDBITS(8 *8字節)大小,也就是64位, 所以在上面循環內, 還要再循環64次
看到這里其實大家都應該有個底了, 為什么要循環那么多次, 因為我們需要通過每個文件描述符對應的file_operations結構體的接口f_op->poll來得知是否已經準備好了

簡單介紹 file_operations

我們都知道,當我們打開一些設備或者文件時, 總是返回一個文件描述符, 其實通過這個文件描述符, 我們通過fget_light 來獲得對應的file結構體, 為什么還要反查這個file, 因為通過這個file結構體可以得到: file_operations結構體

file_operations結構體: 用來存儲驅動內核模塊提供的對設備進行各種操作的函數的指針。該結構體的每個域都對應著驅動內核模塊用來處理某個被請求的事務的函數的地址。

/* linux-2.6.32/include/linux/fs.h */ 
struct file_operations { 
   ... 
    unsigned int (*poll) (struct file *, struct poll_table_struct *);    // select通過這個來獲取狀態 
   ...(其他接口忽略)

do_select 循環體源碼:

/* select.c/do_select() */ 
for (;;) { 
        unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp; 
 
        inp = fds->in; outp = fds->out; exp = fds->ex; 
        rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex; 
 
        for (i = 0; i < n; ++rinp, ++routp, ++rexp) {       
            unsigned long in, out, ex, all_bits, bit = 1, mask, j; 
            unsigned long res_in = 0, res_out = 0, res_ex = 0; 
            const struct file_operations *f_op = NULL; 
            struct file *file = NULL; 
 
            in = *inp++; out = *outp++; ex = *exp++; 
            all_bits = in | out | ex; 
            if (all_bits == 0) { 
                i += __NFDBITS; 
                continue; 
            } 
 
            for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {   // 遍歷64位 
                int fput_needed; 
                if (i >= n) 
                    break; 
                if (!(bit & all_bits)) 
                    continue; 
 
                //在當前進程的struct files_struct中根據所謂的用戶空間文件描述符fd來獲取文件描述符 
                file = fget_light(i, &fput_needed);             
                if (file) { 
                    f_op = file->f_op;          // file_operations結構體 
                    mask = DEFAULT_POLLMASK; 
                    if (f_op && f_op->poll) { 
                        wait_key_set(wait, in, out, bit); 
                        mask = (*f_op->poll)(file, wait); 
                    } 
                    fput_light(file, fput_needed); 
                    if ((mask & POLLIN_SET) && (in & bit)) {    //判斷讀狀態 
                        res_in |= bit; 
                        retval++; 
                        wait = NULL; 
                    } 
                    if ((mask & POLLOUT_SET) && (out & bit)) {  //判斷寫狀態 
                        res_out |= bit; 
                        retval++; 
                        wait = NULL; 
                    } 
                    if ((mask & POLLEX_SET) && (ex & bit)) {    //判斷異常狀態 
                        res_ex |= bit; 
                        retval++; 
                        wait = NULL; 
                    } 
                } 
            } 
            if (res_in) 
                *rinp = res_in; 
            if (res_out) 
                *routp = res_out; 
            if (res_ex) 
                *rexp = res_ex; 
            cond_resched(); 
        } 
        wait = NULL; 
        if (retval || timed_out || signal_pending(current)) 
            break; 
        if (table.error) { 
            retval = table.error; 
            break; 
        } 
 
        /* 
         * If this is the first loop and we have a timeout 
         * given, then we convert to ktime_t and set the to 
         * pointer to the expiry value. 
         */ 
        if (end_time && !to) { 
            expire = timespec_to_ktime(*end_time); 
            to = &expire; 
        } 
 
        if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE, 
                       to, slack)) 
            timed_out = 1; 
    }

當select經歷完上面的流程, 將會有以下結果:

>0: 準備好的文件描述符個數
0: 超時
-1: 出錯或者接收到信號

那我們接下來要做的就是,

通過行FD_ISSET()判斷之前綁定的文件fd, 如果為真, 則進行相應操作
因為select返回后, 之前存好的rdfds, wdfds, exfds都會被清空, 所以需要用FD_SET()重新加入

select實戰

上面已經學習到關于select的相關知識, 那么我們應該要來實戰下:

這次我們需要實現的目標是:

一個程序, 同時連接3個socket_server, 并且將socket_server發送的消息打印出來(不需要響應, 也不需要交互)

程序代碼:

/* filename: test_select.c */ 
 
#include <stdio.h> 
#include <stdlib.h> 
#include <sys/socket.h> 
#include <sys/select.h> 
#include <sys/types.h> 
#include <netinet/in.h> 
#include <unistd.h> 
#include <fcntl.h> 
void main() 
{ 
    // socket1 
    int socketd; 
    char buffer[1025];  
    struct sockaddr_in seraddr; 
    socketd = socket(AF_INET, SOCK_STREAM, 0); 
    seraddr.sin_family = AF_INET; 
    seraddr.sin_port = htons(9997); 
    inet_pton(AF_INET, "127.0.0.1", &seraddr.sin_addr); 
    if (connect(socketd, (struct sockaddr *) &seraddr, sizeof(seraddr))<0) 
    { 
        printf("socketd1 connect failed\n"); 
        exit(3); 
    } 
 
    // socket2 
    int socketd2; 
    char buffer2[1025]; 
    struct sockaddr_in seraddr2; 
    socketd2 = socket(AF_INET, SOCK_STREAM, 0); 
    seraddr2.sin_family = AF_INET; 
    seraddr2.sin_port = htons(9998); 
    inet_pton(AF_INET, "127.0.0.1", &seraddr2.sin_addr); 
    if (connect(socketd2, (struct sockaddr *) &seraddr2, sizeof(seraddr))<0) 
    { 
        printf("socketd2 connect failed\n"); 
        exit(3); 
    } 
 
    // scoket3 
    int socketd3; 
    char buffer3[1025]; 
    struct sockaddr_in seraddr3; 
    socketd3 = socket(AF_INET, SOCK_STREAM, 0); 
    seraddr3.sin_family = AF_INET; 
    seraddr3.sin_port = htons(9999); 
    inet_pton(AF_INET, "127.0.0.1", &seraddr3.sin_addr); 
    if (connect(socketd3, (struct sockaddr *) &seraddr3, sizeof(seraddr))<0) 
    { 
        printf("socketd3 connect failed\n"); 
        exit(3); 
    } 
 
    int maxfdp;   
    fd_set fds;                      // select需要的文件描述符集合  
    maxfdp = socketd3 + 1;           // select 第一個形參就是打開的最大文件描述符+1 
    struct timeval timeout = {3, 0}; // 超時設置 
    while(1) 
    { 
        FD_ZERO(&fds);               // 初始化文件描述符集合 
        FD_SET(socketd, &fds);       // 分別添加以上三個需要監聽的文件描述符 
        FD_SET(socketd2, &fds); 
        FD_SET(socketd3, &fds); 
        select(maxfdp, &fds, NULL, NULL, &timeout); 
        // 通過FD_ISSET 來分別判斷 監聽的文件描述符在fds有沒有被設置成1 
        if (FD_ISSET(socketd, &fds)) 
        { 
            read(socketd, buffer, 1024); 
            printf("1 %s\n",buffer); 
        } 
        if(FD_ISSET(socketd2, &fds)) 
        { 
            read(socketd2, buffer2, 1024); 
            printf("2 %s\n",buffer2); 
             
        } 
        if(FD_ISSET(socketd3, &fds)) 
        { 
            read(socketd3, buffer3, 1024); 
            printf("3 %s\n",buffer3); 
             
        } 
    } 
}

為了快速建立簡單的測試服務端, 所以用python實現簡單socket_server:

# socket1.py 
 
import socket 
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
s.bind(('localhost', 9997)) 
s.listen(2) 
rint 'Socket1 is on ready!' 
client, info = s.accept() 
print info 
while 1: 
    message = raw_input('input: ') 
    client.send(message) 
s.close() 
 
------------------------------- 
# socket2.py 
 
import socket 
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
s.bind(('localhost', 9998)) 
s.listen(2) 
rint 'Socket2 is on ready!' 
client, info = s.accept() 
print info 
while 1: 
    message = raw_input('input: ') 
    client.send(message) 
s.close() 
 
------------------------------- 
# socket3.py 
 
import socket 
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
s.bind(('localhost', 9999)) 
s.listen(2) 
rint 'Socket3 is on ready!' 
client, info = s.accept() 
print info 
while 1: 
    message = raw_input('input: ') 
    client.send(message) 
s.close()

分別運行 socket1.py, socket2.py, socket3.py將會看到如下結果:

# 運行 socket1.py 
[root@iZ23pynfq19Z ~]# python socket1.py  
Socket1 is on ready! 
 
---------------------- 
# 運行 socket1.py 
[root@iZ23pynfq19Z ~]# python socket2.py  
Socket2 is on ready! 
 
---------------------- 
# 運行 socket1.py 
[root@iZ23pynfq19Z ~]# python socket3.py  
Socket3 is on ready!

當我們編譯 test_select.c 并運行時, 將會看到三個服務端都出現了相應的響應:

# 運行 socket1.py 
[root@iZ23pynfq19Z ~]# python socket1.py  
Socket1 is on ready! 
('127.0.0.1', 55951)  # 客戶端連接的信息, 端口不一定相同 
input: 
 
---------------------- 
# 運行 socket1.py 
[root@iZ23pynfq19Z ~]# python socket2.py  
Socket2 is on ready! 
('127.0.0.1', 55921) 
input: 
 
---------------------- 
# 運行 socket1.py 
[root@iZ23pynfq19Z ~]# python socket3.py  
Socket3 is on ready! 
('127.0.0.1', 55933) 
input:

那么我們來嘗試三個服務端分別發送消息到select程序吧:

# socket1.py 
[root@iZ23pynfq19Z ~]# python socket1.py  
Socket1 is on ready! 
('127.0.0.1', 55951)  # 客戶端連接的信息, 端口不一定相同 
input: asd 
input: qwe 
input: as 
input:  
---------------------- 
# socket1.py 
[root@iZ23pynfq19Z ~]# python socket2.py  
Socket2 is on ready! 
('127.0.0.1', 55921) 
input: asd 
input: asd 
input: asd 
input: as 
input: s 
input:  
 
---------------------- 
# socket1.py 
[root@iZ23pynfq19Z ~]# python socket3.py  
Socket3 is on ready! 
('127.0.0.1', 55933) 
input: asd 
input: qwe 
input: a 
input:

將看到select程序都能輸出三個socket_server發出的消息:

需要注意的是:

前面的數字是socket_server的編號, 因為server發送消息的順序是亂的, 所以輸出的編號也是亂的
這次只為驗證select, 所以并沒對程序的健壯性作較好的設計, 所以如果服務端/客戶端刷屏了, 直接ctrl-c終止吧

經過上述的實驗, 我們應該能夠簡單的了解select的用法和效果, 通過select實現IO多路復用, 可以讓我們一定程度上避免多線程/多進程的繁瑣, 在我們日常工作上, 有必要的話嘗試這種方式也不失一種偷懶的方法.

責任編輯：龐桂玉來源： Lin_R的博客