python socket（四）網絡多路複用

  什麼是多路複用， 關於這個問題很感謝知乎一位前輩的回答，在這把它貼出來。

假設你是一個機場的空管， 你需要管理到你機場的所有的航線， 包括進港，出港， 有些航班需要放到停機坪等待，有些航班需要去登機口接乘客。

你會怎麼做?

最簡單的做法，就是你去招一大批空管員，然後每人盯一架飛機， 從進港，接客，排位，出港，航線監控，直至交接給下一個空港，全程監控。

那麼問題就來了：

• 很快你就發現空管塔裏面聚集起來一大票的空管員，交通稍微繁忙一點，新的空管員就已經擠不進來了。
  
• 空管員之間需要協調，屋子裏面就1, 2個人的時候還好，幾十號人以後 ，基本上就成菜市場了。
  
• 空管員經常需要更新一些公用的東西，比如起飛顯示屏，比如下一個小時後的出港排期，最後你會很驚奇的發現，每個人的時間最後都花在了搶這些資源上。
  

現實上我們的空管同時管幾十架飛機稀鬆平常的事情， 他們怎麼做的呢？
他們用這個東西.

這個東西叫flight progress strip. 每一個塊代表一個航班，不同的槽代表不同的狀態，然後一個空管員可以管理一組這樣的塊（一組航班），而他的工作，就是在航班信息有新的更新的時候，把對應的塊放到不同的槽子裏面。

這個東西現在還沒有淘汰哦，只是變成電子的了而已。。

是不是覺得一下子效率高了很多，一個空管塔裏可以調度的航線可以是前一種方法的幾倍到幾十倍。

如果你把每一個航線當成一個Sock(I/O 流), 空管當成你的服務端Sock管理代碼的話.

第一種方法就是最傳統的多進程併發模型 (每進來一個新的I/O流會分配一個新的進程管理。)
第二種方法就是I/O多路複用 (單個線程，通過記錄跟蹤每個I/O流(sock)的狀態，來同時管理多個I/O流 。)

其實“I/O多路複用”這個坑爹翻譯可能是這個概念在中文裏面如此難理解的原因。所謂的I/O多路複用在英文中其實叫 I/O multiplexing. 如果你搜索multiplexing啥意思，基本上都會出這個圖：

於是大部分人都直接聯想到"一根網線，多個sock複用" 這個概念，包括上面的幾個回答， 其實不管你用多進程還是I/O多路複用， 網線都只有一根好伐。多個Sock複用一根網線這個功能是在內核＋驅動層實現的。

重要的事情再說一遍： I/O multiplexing 這裏面的 multiplexing 指的其實是在單個線程通過記錄跟蹤每一個Sock(I/O流)的狀態(對應空管塔裏面的Fight progress strip槽)來同時管理多個I/O流. 發明它的原因，是儘量多的提高服務器的吞吐能力。

是不是聽起來好拗口，看個圖就懂了.

[一張代表性圖片]

在同一個線程裏面， 通過撥開關的方式，來同時傳輸多個I/O流， (學過EE的人現在可以站出來義正嚴辭說這個叫“時分複用”了）。

什麼，你還沒有搞懂“一個請求到來了，nginx使用epoll接收請求的過程是怎樣的”， 多看看這個圖就瞭解了。提醒下，ngnix會有很多鏈接進來， epoll會把他們都監視起來，然後像撥開關一樣，誰有數據就撥向誰，然後調用相應的代碼處理。

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
瞭解這個基本的概念以後，其他的就很好解釋了。

select, poll, epoll 都是I/O多路複用的具體的實現，之所以有這三個鬼存在，其實是他們出現是有先後順序的。

I/O多路複用這個概念被提出來以後， select是第一個實現 (1983 左右在BSD裏面實現的)。

select 被實現以後，很快就暴露出了很多問題。

• select 會修改傳入的參數數組，這個對於一個需要調用很多次的函數，是非常不友好的。
  
• select 如果任何一個sock(I/O stream)出現了數據，select 僅僅會返回，但是並不會告訴你是那個sock上有數據，於是你只能自己一個一個的找，10幾個sock可能還好，要是幾萬的sock每次都找一遍，這個無謂的開銷就頗有海天盛筵的豪氣了。
  
• select 只能監視1024個鏈接， 這個跟草榴沒啥關係哦，linux 定義在頭文件中的，參見FD_SETSIZE。
• select 不是線程安全的，如果你把一個sock加入到select, 然後突然另外一個線程發現，尼瑪，這個sock不用，要收回。對不起，這個select 不支持的，如果你喪心病狂的竟然關掉這個sock, select的標準行爲是。。呃。。不可預測的， 這個可是寫在文檔中的哦.

“If a file descriptor being monitored by select() is closed in another thread, the result is unspecified”
霸不霸氣

於是14年以後(1997年）一幫人又實現了poll, poll 修復了select的很多問題，比如

• poll 去掉了1024個鏈接的限制，於是要多少鏈接呢， 主人你開心就好。
  
• poll 從設計上來說，不再修改傳入數組，不過這個要看你的平臺了，所以行走江湖，還是小心爲妙。

其實拖14年那麼久也不是效率問題， 而是那個時代的硬件實在太弱，一臺服務器處理1千多個鏈接簡直就是神一樣的存在了，select很長段時間已經滿足需求。

但是poll仍然不是線程安全的， 這就意味着，不管服務器有多強悍，你也只能在一個線程裏面處理一組I/O流。你當然可以那多進程來配合了，不過然後你就有了多進程的各種問題。

於是5年以後, 在2002, 大神 Davide Libenzi 實現了epoll.

epoll 可以說是I/O 多路複用最新的一個實現，epoll 修復了poll 和select絕大部分問題, 比如：

• epoll 現在是線程安全的。
  
• epoll 現在不僅告訴你sock組裏面數據，還會告訴你具體哪個sock有數據，你不用自己去找了。
  

epoll 當年的patch，現在還在，下面鏈接可以看得到：
/dev/epoll Home Page

貼一張霸氣的圖，看看當年神一樣的性能（測試代碼都是死鏈了， 如果有人可以刨墳找出來，可以研究下細節怎麼測的).

橫軸Dead connections 就是鏈接數的意思，叫這個名字只是它的測試工具叫deadcon. 縱軸是每秒處理請求的數量，你可以看到，epoll每秒處理請求的數量基本不會隨着鏈接變多而下降的。poll 和/dev/poll 就很慘了。

可是epoll 有個致命的缺點。。只有linux支持。比如BSD上面對應的實現是kqueue。

其實有些國內知名廠商把epoll從安卓裏面裁掉這種腦殘的事情我會主動告訴你嘛。什麼，你說沒人用安卓做服務器，尼瑪你是看不起p2p軟件了啦。

而ngnix 的設計原則裏面， 它會使用目標平臺上面最高效的I/O多路複用模型咯，所以纔會有這個設置。一般情況下，如果可能的話，儘量都用epoll/kqueue吧。

詳細的在這裏:
Connection processing methods

PS: 上面所有這些比較分析，都建立在大併發下面，如果你的併發數太少，用哪個，其實都沒有區別。 如果像是在歐朋數據中心裏面的轉碼服務器那種動不動就是幾萬幾十萬的併發，不用epoll我可以直接去撞牆了。

作者：羅志宇
鏈接：https://www.zhihu.com/question/32163005/answer/55772739
來源：知乎

這個清楚的講解了多路複用。

python實現用select實現多路複用的小例子。

python 裏面提供了select模塊，它是建立在底層OS的select調用基礎之上的。

#!/usr/bin/env python
# author:huangpingyi
# date:2016 10 25
import select
import socket
import sys
import signal
import cPickle
import struct
import argparse

SERVER_HOST = '127.0.0.1'
CHAT_SERVER_NAME = 'server'


def send(channel,*args):
    buffer = cPickle.dumps(args)
    value = socket.htonl(len(buffer))
    size = struct.pack("L",value)
    channel.send(size)
    channel.send(buffer)

def receive(channel):
    size = struct.calcsize("L")
    size = channel.recv(size)
    try:
        size = socket.ntohl(struct.unpack("L",size)[0])
    except struct.error,e:
        return ''
    buf = ''
    while len(buf)<size:
        buf +=channel.recv(size-len(buf))
    return cPickle.loads(buf)[0]


class ChatServer(object):
    def __init__(self, port, backlog = 5):
        self.clients= 0
        self.clientmap = {}
        self.outputs = []
        self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
        self.server.bind((SERVER_HOST, port))
        print 'Server listening to port: %s ...' %port
        self.server.listen(backlog)
        signal.signal(signal.SIGINT, self.sighandler)

    def sighandler(self, signum, frame):
        print 'Shutting down server...'
        for output in self.outputs:
            output.close()
        self.server.close()
    def get_client_name(self, client):
        info = self.clientmap[client]
        host, name = info[0][0],info[1]
        return '@'.join((name,host))

#main function
    def run(self):
        inputs = [self.server, sys.stdin]
        self.outputs = []
        running = True
        while running:
         try:
               readable, writeable, exceptional = select.select(inputs,self.outputs,[])
         except select.error,e:
               break

         for sock in readable:
            if sock == self.server:
               client, address = self.server.accept()
               print "Chat server: got connection %d from %s" %(client.fileno(),address)
               cname = receive(client).split('NAME: ')[1]
               self.clients +=1
               send(client,'CLIENT: ' +str(address[0]))
               inputs.append(client)
               self.clientmap[client] = (address, cname)
               msg = "\n(Connected: New client (%d) from %s)" %(self.clients,self.get_client_name(client))
               for output in self.outputs:
                   send(output,msg)
               self.outputs.append(client)
            elif sock == sys.stdin:
                 junk = sys.stdin.readline()
                 running = False
            else:
                try:
                    data = receive(sock)
                    if data:
                       msg = '\n#['+self.get_client_name(sock)+']>>'+data
                       for output in self.outputs:
                           if output != sock:
                               send(output, msg)
                    else:
                          print "Chat server: %d hung up" % sock.fileno()
                          self.clients -=1
                          sock.close()
                          inputs.remove(sock)
                          self.outputs.remove(sock)
                          msg = "\n(Now hung up:Client from %s)" % self.get_client_name(sock)
                          for output in self.outputs:
                              send(output, msg)
                except socket.error, e:
                       inputs.remove(sock)
                       self.outputs.remove(sock)
        self.server.close()
class ChatClient(object):

   def __init__(self, name, port, host = SERVER_HOST):
       self.name = name
       self.connected = False
       self.host = host
       self.port = port
       self.prompt = '['+'@'.join((name, socket.gethostname().split('.')[0]))+']>'
       try:
           self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
           self.sock.connect((host, self.port))
           self.sock.connect((host, self.port))
           print "Now connected to chat server@ port %d" % self.port
           self.connected = True
           send(self.sock,'NAME: '+self.name)
           data = receive(self.sock)
           addr = data.split('CLIENT: ')[1]
           self.prompt = '[' + '@'.join((self.name, addr)) + ']> '
       except socket.error,e:
           print "Failed to connect to chat server @ port %d" % self.port
           sys.exit(1)
   def run(self):
       while self.connected:
          try:
              sys.stdout.write(self.prompt)
              sys.stdout.flush()
              readable, writeable,exceptional = select.select([0, self.sock], [],[])
              for sock in readable:
                  if sock == 0:
                     data = sys.stdin.readline().strip()
                     if data:send(self.sock, data)
                  elif sock == self.sock:
                     data = receive(self.sock)
                     if not data:
                        print 'Client shutting down.'
                        self.connected = False
                        break
                     else:
                        sys.stdout.write(data +'\n')
                        sys.stdout. flush()
          except KeyboardInterrupt:
               print "CLient interrupted."""
               self.sock.close()
               break

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description = 'Socket Server Example with Select')
    parser.add_argument('--name',action = "store",dest = "name",required = True)
    parser.add_argument('--port',action = "store",dest = "port", type = int, required =True)
    given_args = parser.parse_args()
    port = given_args.port
    name = given_args.name
    if name == CHAT_SERVER_NAME:
       server = ChatServer(port)
       server.run()
    else:
       client = ChatClient(name = name ,port = port)
       client.run()

代碼分析：

          初始化聊天室服務器創建了一些屬性：客戶端數量、客戶端映射和輸出的套接字，重用地址的選項（可以使用同一個端口重啓服務器）。

          還使用了signal模塊捕獲用戶的中斷操作。中斷操作一般通過鍵盤輸入。ChatServer類爲中斷信號（SIGINT）註冊了一個信號處理方法sighandler。信號處理方法捕獲從鍵盤輸入的中斷信號，關閉所有輸出套接字，其中一些套接字可能還有數據等待發送。

          聊天室主要執行方法是run（），在while循環中執行操作。run（）方法註冊了一個select接口，輸入參數是聊天服務器套接字stdin，輸出參數由服務器的輸出列表指定。

調用select.select（）方法後得到三個列表：可讀套接字、可寫套接字和異常套接字。聊天服務器只關心可讀套接字，其中保存了準備被讀取的數據。如果可讀套接字是服務器本身，表示有一個新客戶端連到服務器上了，服務器會讀取客戶端的名字，將其廣播給其他客戶端。如果輸入參數中有內容，聊天服務器就退出。類似地，這個聊天服務器也能處理其他客戶端套接字的輸入，轉播客戶端直接傳送的數據，還能共享客戶端進入和離開聊天室的信息。

效果圖：