解析python select epoll poll的詳細說明

select、poll、epoll三者的區別

select

select最早於1983年出現在4.2BSD中，它通過一個select()系統調用來監視多個檔案描述符的數組(在linux中一切事物皆檔案，塊裝置，socket串連等。)，當select()返回後，該數組中就緒的檔案描述符便會被核心修改標誌位（變成ready），使得進程可以獲得這些檔案描述符從而進行後續的讀寫操作（select會不斷監視網路介面的某個目錄下有多少檔案描述符變成ready狀態【在網路介面中，過來一個串連就會建立一個'檔案'】，變成ready狀態後，select就可以操作這個檔案描述符了）。

【socketserver是通過多線程來處理多個請求，每個串連過來分配一個線程來處理，但是select是單進程的，一個進程執行代碼肯定就是串列的，但是現在就要通過一個進程來實現並發的效果，一個進程下只有一個主線程，也就說說用一個線程實現並發的效果。為什麼要用一個進程實現多並發而不採用多線程實現多並發呢？

==========答：因為一個進程實現多並發比多線程是實現多並發的效率還要高，因為啟動多線程會有很多的開銷，而且CPU要不斷的檢查每個線程的狀態，確定哪個線程是否可以執行。這個對系統來說也是有壓力的，用單進程的話就可以避免這種開銷和給系統帶來的壓力，

那麼單進程是如何?多並發的呢？？？

========答：很巧妙的使用了生產者和消費者的模式（非同步），生產者和消費者可以實現非阻塞，一個socketserver通過select接收多個串連過來（之前的socket一個進程只能接收一個串連，當接收新的串連的時候產生阻塞，因為這個socket進程要先和用戶端進行通訊，二者是彼此互相等待的【用戶端發一條訊息，服務端收到，用戶端等著返回....服務端等著接收.........】一直在阻塞著，這個時候如果再來一個串連，要等之前的那個串連斷了，這個才可以連進來。-----------也就是說用基本的socket實現多進程是阻塞的。為瞭解決這個問題採用每來一個串連產生一個線程，是不阻塞了，但是當線程數量過多的時候，對於cpu來說開銷和壓力是比較大的。）對於單個socket來說，阻塞的時候大部分的時候都是在等待IO操作(網路操作也屬於IO操作)。為了避免這種情況，就出現了非同步=============用戶端發起一個串連，會在服務端註冊一個檔案控制代碼，服務端會不斷輪詢這些檔案控制代碼的列表，主進程和用戶端建立串連而沒有啟動線程，這個時候主進程和用戶端進行互動，其他的用戶端是無法串連主進程的，為了實現主進程既能和已串連的用戶端收發訊息，又能和新的用戶端建立串連，就把輪詢變的非常快（死迴圈）去刷用戶端串連進來的檔案控制代碼的列表，只要用戶端發訊息了，服務端讀取了訊息之後，有另一個列表去接收給用戶端返回的訊息，也不斷的去刷這個列表，刷出來後返回給用戶端，這樣和用戶端的這次通訊就完成了，但是跟用戶端的串連還沒有斷，但是就進入了下一次的輪詢。】

select 優點

select目前幾乎在所有的平台上支援，良好跨平台性。

select 缺點

每次調用select，都需要把fd集合從使用者態拷貝到核心態，這個開銷在fd很多的時候會很大

單個進程能夠監視的fd數量存在最大限制，在linux上預設為1024（可以通過修改宏定義或者重新編譯核心的方式提升這個限制）

並且由於select的fd是放在數組中，並且每次都要線性遍曆整個數組，當fd很多的時候，開銷也很大

python select

調用select的函數為readable,writable,exceptional = select.select(rlist, wlist, xlist[, timeout])，前三個參數都分別是三個列表，數組中的對象均為waitable object:均是整數的檔案描述符（file descriptor）或者一個擁有返迴文件描述符方法fileno()的對象；

rlist: 等待讀就緒的list

wlist: 等待寫就緒的list

errlist: 等待“異常”的list

select方法用來監視檔案描述符，如果檔案描述符發生變化，則擷取該描述符。

1、這三個list可以是一個空的list，但是接收3個空的list是依賴於系統的(在Linux上是可以接受的，但是在window上是不可以的)。

2、當 rlist 序列中的描述符發生可讀時（accetp和read），則擷取發生變化的描述符並添加到 readable 序列中

3、當 wlist 序列中含有描述符時，則將該序列中所有的描述符添加到 writable 序列中

4、當 errlist序列中的控制代碼發生錯誤時，則將該發生錯誤的控制代碼添加到 exceptional 序列中

5、當 逾時時間 未設定，則select會一直阻塞，直到監聽的描述符發生變化

當 逾時時間 ＝ 1 時，那麼如果監聽的控制代碼均無任何變化，則select會阻塞 1 秒，之後返回三個空列表，如果監聽的描述符（fd）有變化，則直接執行。

6、在list中可以接受Ptython的的file對象(比如sys.stdin，或者會被open()和os.open()返回的object)，socket object將會返回socket.socket()。也可以自訂類，只要有一個合適的fileno()的方法(需要真實返回一個檔案描述符，而不是一個隨機的整數)。

select 樣本:

Python的select()方法直接叫用作業系統的IO介面，它監控sockets,open files, and pipes(所有帶fileno()方法的檔案控制代碼)何時變成readable 和writeable, 或者通訊錯誤，select()使得同時監控多個串連變的簡單，並且這比寫一個長迴圈來等待和監控多用戶端串連要高效，因為select直接通過作業系統提供的C的網路介面進行操作，而不是通過Python的解譯器

#coding:UTF8import selectimport socketimport sysimport Queue#建立一個TCP/IP 進程server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)server.setblocking(0)#串連地址和連接埠server_address = ('localhost',10000)print >>sys.stderr,'starting up on %s prot %s' % server_addressserver.bind(server_address)#最大允許連結數server.listen(5)inputs = [ server ]outputs = []message_queues = {}while inputs:    print >>sys.stderr,'\nwaiting for the next event'    readable,writable,exceptional = select.select(inputs,outputs,inputs)    # Handle inputs    for s in readable:             if s is server:            # A "readable" server socket is ready to accept a connection            connection, client_address = s.accept()            print >>sys.stderr, 'new connection from', client_address            #connection.setblocking(0)            inputs.append(connection)                 # Give the connection a queue for data we want to send            message_queues[connection] = Queue.Queue()                else:            data = s.recv(1024)            if data:                # A readable client socket has data                print >>sys.stderr, 'received "%s" from %s' % (data, s.getpeername())                message_queues[s].put(data)  #這個s相當於connection                # Add output channel for response                if s not in outputs:                    outputs.append(s)            else:                # Interpret empty result as closed connection                print >>sys.stderr, 'closing', client_address, 'after reading no data'                # Stop listening for input on the connection                if s in outputs:                    outputs.remove(s)  #既然用戶端都斷開了，我就不用再給它返回資料了，所以這時候如果這個用戶端的連線物件還在outputs列表中，就把它刪掉                inputs.remove(s)    #inputs中也刪除掉                s.close()           #把這個串連關閉掉                                 # Remove message queue                del message_queues[s]        # Handle outputs    for s in writable:        try:            next_msg = message_queues[s].get_nowait()        except Queue.Empty:            # No messages waiting so stop checking for writability.            print >>sys.stderr, 'output queue for', s.getpeername(), 'is empty'            outputs.remove(s)        else:            print >>sys.stderr, 'sending "%s" to %s' % (next_msg, s.getpeername())            s.send(next_msg.upper())    # Handle "exceptional conditions"    for s in exceptional:        print >>sys.stderr, 'handling exceptional condition for', s.getpeername()        # Stop listening for input on the connection        inputs.remove(s)        if s in outputs:            outputs.remove(s)        s.close()             # Remove message queue        del message_queues[s]     server

代碼解析：

select()方法接收並監控3個通訊列表， 第一個是所有的輸入的data,就是指外部發過來的資料，第2個是監控和接收所有要發出去的data(outgoing data),第3個監控錯誤資訊，接下來我們需要建立2個列表來包含輸入和輸出資訊來傳給select().

# Sockets from which we expect to readinputs = [ server ]# Sockets to which we expect to writeoutputs = [ ]

所有用戶端的進來的串連和資料將會被server的主迴圈程式放在上面的list中處理，我們現在的server端需要等待串連可寫（writable)之後才能過來，然後接收資料並返回(因此不是在接收到資料之後就立刻返回)，因為每個串連要把輸入或輸出的資料先緩衝到queue裡，然後再由select取出來再發出去。

# Outgoing message queues (socket:Queue)message_queues = {}

The main portion of the server program loops, calling select() to block and wait for network activity.

下面是此程式的主迴圈，調用select()時會阻塞和等待直到新的串連和資料進來

while inputs: # Wait for at least one of the sockets to be ready for processing print >>sys.stderr, '\nwaiting for the next event' readable, writable, exceptional = select.select(inputs, outputs, inputs)

當你把inputs,outputs,exceptional(這裡跟inputs共用)傳給select()後，它返回3個新的list，我們上面將他們分別賦值為readable,writable,exceptional, 所有在readable list中的socket串連代表有資料可接收(recv),所有在writable list中的存放著你可以對其進行發送(send)操作的socket串連，當串連通訊出現error時會把error寫到exceptional列表中。

Readable list 中的socket 可以有3種可能狀態，第一種是如果這個socket是main "server" socket,它負責監聽用戶端的串連，如果這個main server socket出現在readable裡，那代表這是server端已經ready來接收一個新的串連進來了，為了讓這個main server能同時處理多個串連，在下面的代碼裡，我們把這個main server的socket設定為非阻塞模式。

第二種情況是這個socket是已經建立了的串連，它把資料發了過來，這個時候你就可以通過recv()來接收它發過來的資料，然後把接收到的資料放到queue裡，這樣你就可以把接收到的資料再傳回給用戶端了。

第三種情況就是這個用戶端已經斷開了，所以你再通過recv()接收到的資料就為空白了，所以這個時候你就可以把這個跟用戶端的串連關閉了。

對於writable list中的socket，也有幾種狀態，如果這個用戶端串連在跟它對應的queue裡有資料，就把這個資料取出來再發回給這個用戶端，否則就把這個串連從output list中移除，這樣下一次迴圈select()調用時檢測到outputs list中沒有這個串連，那就會認為這個串連還處於非使用中

最後，如果在跟某個socket串連通訊過程中出了錯誤，就把這個連線物件在inputs\outputs\message_queue中都刪除，再把串連關閉掉

#coding:UTF8import socketimport sys messages = [ 'This is the message. ',             'It will be sent ',             'in parts.',             ]server_address = ('localhost', 10003) # Create a TCP/IP socketsocks = [ socket.socket(socket.AF_INET, socket.SOCK_STREAM),          socket.socket(socket.AF_INET, socket.SOCK_STREAM),          ] # Connect the socket to the port where the server is listeningprint >>sys.stderr, 'connecting to %s port %s' % server_addressfor s in socks:    s.connect(server_address)for message in messages:     # Send messages on both sockets    for s in socks:        print >>sys.stderr, '%s: sending "%s"' % (s.getsockname(), message)        s.send(message)     # Read responses on both sockets    for s in socks:        data = s.recv(1024)        print >>sys.stderr, '%s: received "%s"' % (s.getsockname(), data)        if not data:            print >>sys.stderr, 'closing socket', s.getsockname()client

用戶端程式展示了如何通過select()對socket進行管理並與多個串連同時進行互動，通過迴圈通過每個socket串連給server發送和接收資料。

server：starting up on localhost prot 10000waiting for the next eventnew connection from ('127.0.0.1', 54812)waiting for the next eventnew connection from ('127.0.0.1', 54813)received "This is the message. " from ('127.0.0.1', 54812)waiting for the next eventreceived "This is the message. " from ('127.0.0.1', 54813)sending "This is the message. " to ('127.0.0.1', 54812)waiting for the next eventoutput queue for ('127.0.0.1', 54812) is emptysending "This is the message. " to ('127.0.0.1', 54813)waiting for the next eventoutput queue for ('127.0.0.1', 54813) is emptywaiting for the next eventreceived "It will be sent " from ('127.0.0.1', 54812)received "It will be sent " from ('127.0.0.1', 54813)waiting for the next eventsending "It will be sent " to ('127.0.0.1', 54812)sending "It will be sent " to ('127.0.0.1', 54813)waiting for the next eventoutput queue for ('127.0.0.1', 54812) is emptyoutput queue for ('127.0.0.1', 54813) is emptywaiting for the next eventreceived "in parts." from ('127.0.0.1', 54812)received "in parts." from ('127.0.0.1', 54813)waiting for the next eventsending "in parts." to ('127.0.0.1', 54812)sending "in parts." to ('127.0.0.1', 54813)waiting for the next eventoutput queue for ('127.0.0.1', 54812) is emptyoutput queue for ('127.0.0.1', 54813) is emptywaiting for the next eventclosing ('127.0.0.1', 54813) after reading no dataclosing ('127.0.0.1', 54813) after reading no datawaiting for the next eventclient：connecting to localhost port 10000('127.0.0.1', 54812): sending "This is the message. "('127.0.0.1', 54813): sending "This is the message. "('127.0.0.1', 54812): received "THIS IS THE MESSAGE. "('127.0.0.1', 54813): received "THIS IS THE MESSAGE. "('127.0.0.1', 54812): sending "It will be sent "('127.0.0.1', 54813): sending "It will be sent "('127.0.0.1', 54812): received "IT WILL BE SENT "('127.0.0.1', 54813): received "IT WILL BE SENT "('127.0.0.1', 54812): sending "in parts."('127.0.0.1', 54813): sending "in parts."('127.0.0.1', 54812): received "IN PARTS."('127.0.0.1', 54813): received "IN PARTS."運行結果

poll
poll在1986年誕生於System V Release 3，它和select在本質上沒有多大差別，但是poll沒有最大檔案描述符數量的限制。

poll和select同樣存在一個缺點就是，包含大量檔案描述符的數組被整體複製於使用者態和核心的地址空間之間，而不論這些檔案描述符是否就緒，它的開銷隨著檔案描述符數量的增加而線性增大。

另外，select()和poll()將就緒的檔案描述符告訴進程後，如果進程沒有對其進行IO操作，那麼下次調用select()和poll() 的時候將再次報告這些檔案描述符，所以它們一般不會丟失就緒的訊息，這種方式稱為水平觸發（Level Triggered）。

在Python中調用poll

select.poll()，返回一個poll的對象，支援註冊和登出檔案描述符。

poll.register(fd[, eventmask])註冊一個檔案描述符，註冊後，可以通過poll()方法來檢查是否有對應的I/O事件發生。fd可以是i 個整數，或者有返回整數的fileno()方法對象。如果File對象實現了fileno()，也可以當作參數使用。

eventmask是一個你想去檢查的事件類型，它可以是常量POLLIN, POLLPRI和 POLLOUT的組合。如果預設，預設會去檢查所有的3種事件類型。

事件常量意義

POLLIN有資料讀取

POLLPRT有資料緊急讀取

POLLOUT準備輸出:輸出不會阻塞

POLLERR某些錯誤情況出現

POLLHUP掛起

POLLNVAL無效請求:描述無法開啟

poll.modify(fd, eventmask) 修改一個已經存在的fd，和poll.register(fd, eventmask)有相同的作用。如果去嘗試修改一個未經註冊的fd，會引起一個errno為ENOENT的IOError。

poll.unregister(fd)從poll對象中登出一個fd。嘗試去登出一個未經註冊的fd，會引起KeyError。

poll.poll([timeout])去檢測已經註冊了的檔案描述符。會返回一個可能為空白的list，list中包含著(fd, event)這樣的二元組。 fd是檔案描述符， event是檔案描述符對應的事件。如果返回的是一個空的list，則說明逾時了且沒有檔案描述符有事件發生。timeout的單位是milliseconds，如果設定了timeout，系統將會等待對應的時間。如果timeout預設或者是None，這個方法將會阻塞直到對應的poll對象有一個事件發生。

#coding: utf-8 import select, socketresponse = b"hello world"serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)serversocket.bind(('localhost', 10000))serversocket.listen(1)serversocket.setblocking(0)#poll = select.poll()poll.register(serversocket.fileno(), select.POLLIN)connections = {}while True:    for fd, event in poll.poll():        if event == select.POLLIN:            if fd == serversocket.fileno():                con, addr = serversocket.accept()                poll.register(con.fileno(), select.POLLIN)                connections[con.fileno()] = con            else:                con = connections[fd]                data = con.recv(1024)                if data:                    poll.modify(con.fileno(), select.POLLOUT)        elif event == select.POLLOUT:            con = connections[fd]            con.send(response)            poll.unregister(con.fileno())            con.close()

epoll
直到Linux2.6才出現了由核心直接支援的實現方法，那就是epoll，它幾乎具備了之前所說的一切優點，被公認為Linux2.6下效能最好的多路I/O就緒通知方法。

epoll可以同時支援水平觸發和邊緣觸發（Edge Triggered，只告訴進程哪些檔案描述符剛剛變為就緒狀態，它只說一遍，如果我們沒有採取行動，那麼它將不會再次告知，這種方式稱為邊緣觸發），理論上邊緣觸發的效能要更高一些，但是代碼實現相當複雜。

epoll同樣只告知那些就緒的檔案描述符，而且當我們調用epoll_wait()獲得就緒檔案描述符時，返回的不是實際的描述符，而是一個代表 就緒描述符數量的值，你只需要去epoll指定的一個數組中依次取得相應數量的檔案描述符即可，這裡也使用了記憶體映射（mmap）技術，這樣便徹底省掉了 這些檔案描述符在系統調用時複製的開銷。

另一個本質的改進在於epoll採用基於事件的就緒通知方式。在select/poll中，進程只有在調用一定的方法後，核心才對所有監視的檔案描 述符進行掃描，而epoll事先通過epoll_ctl()來註冊一個檔案描述符，一旦基於某個檔案描述符就緒時，核心會採用類似callback的回調 機制，迅速啟用這個檔案描述符，當進程調用epoll_wait()時便得到通知。

在Python中調用epoll

select.epoll([sizehint=-1])返回一個epoll對象。

eventmask

事件常量意義

EPOLLIN讀就緒

EPOLLOUT寫就緒

EPOLLPRI有資料緊急讀取

EPOLLERRassoc. fd有錯誤情況發生

EPOLLHUPassoc. fd發生掛起

EPOLLRT設定邊緣觸發(ET)（預設的是水平觸發）

EPOLLONESHOT設定為 one-short 行為，一個事件(event)被拉出後，對應的fd在內部被禁用

EPOLLRDNORM和 EPOLLIN 相等

EPOLLRDBAND優先讀取的資料帶(data band)

EPOLLWRNORM和 EPOLLOUT 相等

EPOLLWRBAND優先寫的資料帶(data band)

EPOLLMSG忽視

epoll.close()關閉epoll對象的檔案描述符。

epoll.fileno返回control fd的檔案描述符number。

epoll.fromfd(fd)用給予的fd來建立一個epoll對象。

epoll.register(fd[, eventmask])在epoll對象中註冊一個檔案描述符。（如果檔案描述符已經存在，將會引起一個IOError）

epoll.modify(fd, eventmask)修改一個已經註冊的檔案描述符。

epoll.unregister(fd)登出一個檔案描述符。

epoll.poll(timeout=-1[, maxevnets=-1])等待事件，timeout(float)的單位是秒（second）。

#coding:Utf8import socket, selectEOL1 = b'\n\n'EOL2 = b'\n\r\n'response  = b'HTTP/1.0 200 OK\r\nDate: Mon, 1 Jan 1996 01:01:01 GMT\r\n'response += b'Content-Type: text/plain\r\nContent-Length: 13\r\n\r\n'response += b'Hello, world!'serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)serversocket.bind(('localhost', 10000))serversocket.listen(1)serversocket.setblocking(0)epoll = select.epoll()epoll.register(serversocket.fileno(), select.EPOLLIN)try:   connections = {}; requests = {}; responses = {}   while True:      events = epoll.poll(1)      for fileno, event in events:         if fileno == serversocket.fileno():            connection, address = serversocket.accept()            connection.setblocking(0)            epoll.register(connection.fileno(), select.EPOLLIN)            connections[connection.fileno()] = connection            requests[connection.fileno()] = b''            responses[connection.fileno()] = response         elif event & select.EPOLLIN:            requests[fileno] += connections[fileno].recv(1024)            if EOL1 in requests[fileno] or EOL2 in requests[fileno]:               epoll.modify(fileno, select.EPOLLOUT)               print('-'*40 + '\n' + requests[fileno].decode()[:-2])         elif event & select.EPOLLOUT:            byteswritten = connections[fileno].send(responses[fileno])            responses[fileno] = responses[fileno][byteswritten:]            if len(responses[fileno]) == 0:               epoll.modify(fileno, 0)               connections[fileno].shutdown(socket.SHUT_RDWR)         elif event & select.EPOLLHUP:            epoll.unregister(fileno)            connections[fileno].close()            del connections[fileno]finally:   epoll.unregister(serversocket.fileno())   epoll.close()   serversocket.close()