Asyncore模塊提供了以異步的方式寫入套接字服務(wù)客戶端和服務(wù)器的基礎(chǔ)結(jié)構(gòu)。

只有兩種方式使一個程序在單處理器上實現(xiàn)“同時做不止一件事”。多線程編程是最簡單和最流行的方式，但是有另一種很不一樣的技術(shù)，可以使得我們保持多線程的幾乎所有優(yōu)勢，卻不用真正使用多線程。 如果你的程序主要是受I/O限制的，這是唯一可行的方式。如果你的程序是受處理器限制的，則先發(fā)制人的調(diào)度線程可能是你真正需要的。但是，很少網(wǎng)絡(luò)服務(wù)器是受處理器限制的。

如果您的操作系統(tǒng)支持在其I / O庫的 select() 系統(tǒng)調(diào)用（幾乎所有系統(tǒng)都支持），那么你可以用它一次處理多個通信信道;當(dāng)你的I/O在后臺忙碌時處理其他工作。雖然這一策略似乎很奇怪很復(fù)雜，尤其是最開始的時候，這在很多方面比多線程編程更容易理解和控制。asyncore 模塊為你解決了很多困難，使你能快速構(gòu)建復(fù)雜的高性能網(wǎng)絡(luò)服務(wù)器和客戶端。對于會話應(yīng)用程序和協(xié)議， asynchat 模塊是非常有用的。

兩個模塊背后的想法就是創(chuàng)建一個或者多個網(wǎng)絡(luò) 通道, 及 asyncore.dispatcher 和 asynchat.async_chat 類的實例. 如果你沒有提供自己的映射的話，創(chuàng)建通道會把這兩個實例加到由 loop() 函數(shù)使用的全局映射中。

一旦初始化通道被創(chuàng)建，調(diào)用 loop() 函數(shù)會激活通道服務(wù)，這會持續(xù)到最后一個通道（包括所有在異步服務(wù)中被加到映射中的通道）被關(guān)閉。
該模塊文件包含一個loop()函數(shù)和一個dispatcher基類，其中l(wèi)oop()函數(shù)是全局函數(shù)，負(fù)責(zé)檢查一個保存著dispatcher實例的dict，也被稱為channel。
每一個繼承dispatcher類的對象，都可以看作需要處理的socket，因此使用時我們只需定義一個繼承dispatcher的類，然后重寫一些方法就行，一般都是以handle_開頭的方法。

端口轉(zhuǎn)發(fā)的示例
如果你的程序想在同一時間做一件一上的事情，多線程是最快也最普遍的方式，但還有一個方式，在I/O流量很大的時候特別實用。如果你的操作系統(tǒng)支持select函數(shù)，你就可以讓I/O在后臺讀寫。這個模塊聽起來很復(fù)雜，但實際上有很多方式可以理解它，這個文檔幫你解決了這些問題。
我感覺這個模塊應(yīng)該是一個以事件驅(qū)動的異步I/O，跟C++的事件選擇模型類似。每當(dāng)發(fā)生了讀、寫事件后，會交由我們重寫的事件函數(shù)進(jìn)行處理。
我這里有一個使用asyncore模塊編寫端口轉(zhuǎn)發(fā)腳本，從這個腳本可以大概了解asyncore的基本使用。
在文章中，所說的客戶端就是我們的電腦，服務(wù)端是轉(zhuǎn)發(fā)到的地址。也就是客戶端發(fā)送到這個腳本的信息，這個腳本轉(zhuǎn)發(fā)到服務(wù)端上。
首先，定義一個forwarder類：

class forwarder(asyncore.dispatcher):
  def __init__(self, ip, port, remoteip,remoteport,backlog=5):
    asyncore.dispatcher.__init__(self)
    self.remoteip=remoteip
    self.remoteport=remoteport
    self.create_socket(socket.AF_INET,socket.SOCK_STREAM)
    self.set_reuse_addr()
    self.bind((ip,port))
    self.listen(backlog)

  def handle_accept(self):
    conn, addr = self.accept()
    # print '--- Connect --- '
    sender(receiver(conn),self.remoteip,self.remoteport)

這個類繼承自asyncore模塊的dispatcher類（它就是我們的主要的類，其中包括了一些之后要重載的函數(shù)），構(gòu)造函數(shù)獲得5個參數(shù)，第1、2個參數(shù)是腳本監(jiān)聽的本地IP和端口，第3、4個參數(shù)是服務(wù)端的IP和端口。第5個參數(shù)是listen函數(shù)的參數(shù)，等待隊列最大長度。
如何使用這個類，只需要如下新建一個對象，把相應(yīng)IP和端口傳入，再進(jìn)入loop即可：

forwarder(options.local_ip,options.local_port,options.remote_ip,options.remote_port)
asyncore.loop()

進(jìn)入loop后相當(dāng)于開啟了一個守護(hù)線程，在后臺一直運(yùn)行著，等待socket事件的發(fā)生。
因為我們這個腳本是端口轉(zhuǎn)發(fā)工具，所以實際上運(yùn)行的過程是：客戶端連接這個腳本的端口，讓后發(fā)送給這個端口的數(shù)據(jù)腳本自動轉(zhuǎn)發(fā)到服務(wù)端地址和端口。所以，首先接收到的應(yīng)該是連接消息（accept事件）。
那么，當(dāng)accept事件發(fā)生后，就進(jìn)入了handle_accept函數(shù)中。所以我們看到，handle_accept函數(shù)實際上就是調(diào)用了accept函數(shù)接收了客戶端連接對象和地址。獲得了之后又新建了一個sender類對象，這個對象定義如下：

class sender(asyncore.dispatcher):
  def __init__(self, receiver, remoteaddr,remoteport):
    asyncore.dispatcher.__init__(self)
    self.receiver=receiver
    receiver.sender=self
    self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
    self.connect((remoteaddr, remoteport))

  def handle_connect(self):
    pass

  def handle_read(self):
    read = self.recv(4096)
    # print '<-- %04i'%len(read)
    self.receiver.to_remote_buffer += read

  def writable(self):
    return (len(self.receiver.from_remote_buffer) > 0)

  def handle_write(self):
    sent = self.send(self.receiver.from_remote_buffer)
    # print '--> %04i'%sent
    self.receiver.from_remote_buffer = self.receiver.from_remote_buffer[sent:]

  def handle_close(self):
    self.close()
    self.receiver.close()

這個類也是繼承自asyncore.dispatcher，它的構(gòu)造函數(shù)接收3個參數(shù)，分別是recv對象（這個之后說到），遠(yuǎn)端地址，對應(yīng)端口。
函數(shù)中又新建了一個socket，這個socket就是和服務(wù)端端口通信的socket，然后調(diào)用connect連接這個端口。
之后其實也是進(jìn)入了一個等待消息的過程，因為我們發(fā)送了一個connect，所以下一次接收到的消息應(yīng)該是connect，而handle_connect是一個pass掉的函數(shù)。沒有執(zhí)行任何內(nèi)容。
在連接完成后，我們就相當(dāng)于建立好了一個端口轉(zhuǎn)發(fā)的通道。當(dāng)客戶端向這個腳本監(jiān)聽的端口發(fā)送數(shù)據(jù)包時，它就會自動轉(zhuǎn)發(fā)到服務(wù)端端口上。服務(wù)端端口返回的數(shù)據(jù)包，會自動轉(zhuǎn)發(fā)到客戶端上。
回到構(gòu)造函數(shù)的第1個參數(shù)，我們在forwarder類函數(shù)中可以看到，傳入的是一個receiver(conn)對象，receiver也是一個類，我們來看看這個類的定義：

class receiver(asyncore.dispatcher):
  def __init__(self,conn):
    asyncore.dispatcher.__init__(self,conn)
    self.from_remote_buffer=''
    self.to_remote_buffer=''
    self.sender=None

  def handle_connect(self):
    pass

  def handle_read(self):
    read = self.recv(4096)
    # print '%04i -->'%len(read)
    self.from_remote_buffer += read

  def writable(self):
    return (len(self.to_remote_buffer) > 0)

  def handle_write(self):
    sent = self.send(self.to_remote_buffer)
    # print '%04i <--'%sent
    self.to_remote_buffer = self.to_remote_buffer[sent:]

  def handle_close(self):
    self.close()
    if self.sender:
      self.sender.close()

它也是繼承了asyncore.dispatcher，構(gòu)造函數(shù)只接收一個參數(shù)，就是connect的返回值，一個連接對象。
實際上這個對象它就是監(jiān)聽、處理與客戶端的通信，而之前說的sender對象是監(jiān)聽、處理與服務(wù)端的通信。                   

最新評論