首先列一下，sellect、poll、epoll三者的差別
select
select最早于1983年出現在4.2BSD中，它通過一個select()系統調用來監視多個檔案描述符的數組，當select()傳回後，該數組中就緒的檔案描述符便會被核心修改标志位，使得程序可以獲得這些檔案描述符進而進行後續的讀寫操作。
select目前幾乎在所有的平台上支援，其良好跨平台支援也是它的一個優點，事實上從現在看來，這也是它所剩不多的優點之一。
select的一個缺點在于單個程序能夠監視的檔案描述符的數量存在最大限制，在Linux上一般為1024，不過可以通過修改宏定義甚至重新編譯核心的方式提升這一限制。
另外，select()所維護的存儲大量檔案描述符的資料結構，随着檔案描述符數量的增大，其複制的開銷也線性增長。同時，由于網絡響應時間的延遲使得大量TCP連接配接處于非活躍狀态，但調用select()會對所有socket進行一次線性掃描，是以這也浪費了一定的開銷。
poll
poll在1986年誕生于System V Release 3，它和select在本質上沒有多大差别，但是poll沒有最大檔案描述符數量的限制。
poll和select同樣存在一個缺點就是，包含大量檔案描述符的數組被整體複制于使用者态和核心的位址空間之間，而不論這些檔案描述符是否就緒，它的開銷随着檔案描述符數量的增加而線性增大。
另外，select()和poll()将就緒的檔案描述符告訴程序後，如果程序沒有對其進行IO操作，那麼下次調用select()和poll()的時候将再次報告這些檔案描述符，是以它們一般不會丢失就緒的消息，這種方式稱為水準觸發（Level Triggered）。
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 select
Python的select()方法直接調用作業系統的IO接口，它監控sockets,open files, and pipes(所有帶fileno()方法的檔案句柄)何時變成readable 和writeable, 或者通信錯誤，select()使得同時監控多個連接配接變的簡單，并且這比寫一個長循環來等待和監控多用戶端連接配接要高效，因為select直接通過作業系統提供的C的網絡接口進行操作，而不是通過Python的解釋器。
注意：Using Python’s file objects with select() works for Unix, but is not supported under Windows.
接下來通過echo server例子要以了解select 是如何通過單程序實作同時處理多個非阻塞的socket連接配接的
import select
import socket
import sys
import Queue
# Create a TCP/IP socket
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setblocking(0)
# Bind the socket to the port
server_address = ('localhost', 10000)
print >>sys.stderr, 'starting up on %s port %s' % server_address
server.bind(server_address)
# Listen for incoming connections
server.listen(5)
select()方法接收并監控3個通信清單， 第一個是所有的輸入的data,就是指外部發過來的資料，第2個是監控和接收所有要發出去的data(outgoing data),第3個監控錯誤資訊，接下來我們需要建立2個清單來包含輸入和輸出資訊來傳給select().
# Sockets from which we expect to read
inputs = [ server ]
# Sockets to which we expect to write
outputs = [ ]
所有用戶端的進來的連接配接和資料将會被server的主循環程式放在上面的list中處理，我們現在的server端需要等待連接配接可寫（writable)之後才能過來，然後接收資料并傳回(是以不是在接收到資料之後就立刻傳回)，因為每個連接配接要把輸入或輸出的資料先緩存到queue裡，然後再由select取出來再發出去。
Connections are added to and removed from these lists by the server main loop. Since this version of the server is going to wait for a socket to become writable before sending any data (instead of immediately sending the reply), each output connection needs a queue to act as a buffer for the data to be sent through it.
# 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清單中。
select() returns three new lists, containing subsets of the contents of the lists passed in. All of the sockets in the readable list have incoming data buffered and available to be read. All of the sockets in the writable list have free space in their buffer and can be written to. The sockets returned in exceptional have had an error (the actual definition of “exceptional condition” depends on the platform).
Readable list 中的socket 可以有3種可能狀态，第一種是如果這個socket是main "server" socket,它負責監聽用戶端的連接配接，如果這個main server socket出現在readable裡，那代表這是server端已經ready來接收一個新的連接配接進來了，為了讓這個main server能同時處理多個連接配接，在下面的代碼裡，我們把這個main server的socket設定為非阻塞模式。
The “readable” sockets represent three possible cases. If the socket is the main “server” socket, the one being used to listen for connections, then the “readable” condition means it is ready to accept another incoming connection. In addition to adding the new connection to the list of inputs to monitor, this section sets the client socket to not block.
# 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()
第二種情況是這個socket是已經建立了的連接配接，它把資料發了過來，這個時候你就可以通過recv()來接收它發過來的資料，然後把接收到的資料放到queue裡，這樣你就可以把接收到的資料再傳回給用戶端了。
The next case is an established connection with a client that has sent data. The data is read with recv(), then placed on the queue so it can be sent through the socket and back to the client.
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)
# Add output channel for response
if s not in outputs:
outputs.append(s)
第三種情況就是這個用戶端已經斷開了，是以你再通過recv()接收到的資料就為空了，是以這個時候你就可以把這個跟用戶端的連接配接關閉了。
A readable socket without data available is from a client that has disconnected, and the stream is ready to be closed.
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]
對于writable list中的socket，也有幾種狀态，如果這個用戶端連接配接在跟它對應的queue裡有資料，就把這個資料取出來再發回給這個用戶端，否則就把這個連接配接從output list中移除，這樣下一次循環select()調用時檢測到outputs list中沒有這個連接配接，那就會認為這個連接配接還處于非活動狀态
There are fewer cases for the writable connections. If there is data in the queue for a connection, the next message is sent. Otherwise, the connection is removed from the list of output connections so that the next time through the loop select() does not indicate that the socket is ready to send data.
# 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)
最後，如果在跟某個socket連接配接通信過程中出了錯誤，就把這個連接配接對象在inputs\outputs\message_queue中都删除，再把連接配接關閉掉
# 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]
用戶端
下面的這個是用戶端程式展示了如何通過select()對socket進行管理并與多個連接配接同時進行互動，
The example client program uses two sockets to demonstrate how the server with select() manages multiple connections at the same time. The client starts by connecting each TCP/IP socket to the server.
import socket
import sys
messages = [ 'This is the message. ',
'It will be sent ',
'in parts.',
]
server_address = ('localhost', 10000)
# Create a TCP/IP socket
socks = [ 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 listening
print >>sys.stderr, 'connecting to %s port %s' % server_address
for s in socks:
s.connect(server_address)
接下來通過循環通過每個socket連接配接給server發送和接收資料。
Then it sends one pieces of the message at a time via each socket, and reads all responses available after writing new data.
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()
最後伺服器端的完整代碼如下：
#_*_coding:utf-8_*_
__author__ = 'Alex Li'
import select
import socket
import sys
import queue
# Create a TCP/IP socket
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setblocking(False)
# Bind the socket to the port
server_address = ('localhost', 10000)
print(sys.stderr, 'starting up on %s port %s' % server_address)
server.bind(server_address)
# Listen for incoming connections
server.listen(5)
# Sockets from which we expect to read
inputs = [ server ]
# Sockets to which we expect to write
outputs = [ ]
message_queues = {}
while inputs:
# Wait for at least one of the sockets to be ready for processing
print( '\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('new connection from', client_address)
connection.setblocking(False)
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)
# Add output channel for response
if s not in outputs:
outputs.append(s)
else:
# Interpret empty result as closed connection
print('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('output queue for', s.getpeername(), 'is empty')
outputs.remove(s)
else:
print( 'sending "%s" to %s' % (next_msg, s.getpeername()))
s.send(next_msg)
# Handle "exceptional conditions"
for s in exceptional:
print('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]
用戶端的完整代碼如下： __author__ = 'jieli'
import socket
import sys
messages = [ 'This is the message. ',
'It will be sent ',
'in parts.',
]
server_address = ('localhost', 10000)
# Create a TCP/IP socket
socks = [ 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 listening
print >>sys.stderr, 'connecting to %s port %s' % server_address
for 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()
s.close()
Run the server in one window and the client in another. The output will look like this, with different port numbers.
$ python ./select_echo_server.py
starting up on localhost port 10000
waiting for the next event
new connection from ('127.0.0.1', 55821)
waiting for the next event
new connection from ('127.0.0.1', 55822)
received "This is the message. " from ('127.0.0.1', 55821)
waiting for the next event
sending "This is the message. " to ('127.0.0.1', 55821)
waiting for the next event
output queue for ('127.0.0.1', 55821) is empty
waiting for the next event
received "This is the message. " from ('127.0.0.1', 55822)
waiting for the next event
sending "This is the message. " to ('127.0.0.1', 55822)
waiting for the next event
output queue for ('127.0.0.1', 55822) is empty
waiting for the next event
received "It will be sent " from ('127.0.0.1', 55821)
received "It will be sent " from ('127.0.0.1', 55822)
waiting for the next event
sending "It will be sent " to ('127.0.0.1', 55821)
sending "It will be sent " to ('127.0.0.1', 55822)
waiting for the next event
output queue for ('127.0.0.1', 55821) is empty
output queue for ('127.0.0.1', 55822) is empty
waiting for the next event
received "in parts." from ('127.0.0.1', 55821)
received "in parts." from ('127.0.0.1', 55822)
waiting for the next event
sending "in parts." to ('127.0.0.1', 55821)
sending "in parts." to ('127.0.0.1', 55822)
waiting for the next event
output queue for ('127.0.0.1', 55821) is empty
output queue for ('127.0.0.1', 55822) is empty
waiting for the next event
closing ('127.0.0.1', 55822) after reading no data
closing ('127.0.0.1', 55822) after reading no data
waiting for the next event
The client output shows the data being sent and received using both sockets.
$ python ./select_echo_multiclient.py
connecting to localhost port 10000
('127.0.0.1', 55821): sending "This is the message. "
('127.0.0.1', 55822): sending "This is the message. "
('127.0.0.1', 55821): received "This is the message. "
('127.0.0.1', 55822): received "This is the message. "
('127.0.0.1', 55821): sending "It will be sent "
('127.0.0.1', 55822): sending "It will be sent "
('127.0.0.1', 55821): received "It will be sent "
('127.0.0.1', 55822): received "It will be sent "
('127.0.0.1', 55821): sending "in parts."
('127.0.0.1', 55822): sending "in parts."
('127.0.0.1', 55821): received "in parts."
('127.0.0.1', 55822): received "in parts." 原文：http://pymotw.com/2/select/