### 導航 - [索引](../genindex.xhtml "總目錄") - [模塊](../py-modindex.xhtml "Python 模塊索引") | - [下一頁](asynchat.xhtml "asynchat --- 異步 socket 指令/響應 處理器") | - [上一頁](selectors.xhtml "selectors --- 高級 I/O 復用庫") | -  - [Python](https://www.python.org/) ? - zh\_CN 3.7.3 [文檔](../index.xhtml) ? - [Python 標準庫](index.xhtml) ? - [網絡和進程間通信](ipc.xhtml) ? - $('.inline-search').show(0); | # [`asyncore`](#module-asyncore "asyncore: A base class for developing asynchronous socket handling services.") --- 異步socket處理器 **源碼：** [Lib/asyncore.py](https://github.com/python/cpython/tree/3.7/Lib/asyncore.py) \[https://github.com/python/cpython/tree/3.7/Lib/asyncore.py\] 3\.6 版后已移除: 請使用 [`asyncio`](asyncio.xhtml#module-asyncio "asyncio: Asynchronous I/O.") 替代。 - - - - - - 注解 該模塊僅為提供向后兼容。我們推薦在新代碼中使用 [`asyncio`](asyncio.xhtml#module-asyncio "asyncio: Asynchronous I/O.") 。 該模塊提供用于編寫異步套接字服務客戶端與服務端的基礎構件。 只有兩種方法讓單個處理器上的程序“同一時間完成不止一件事”。 多線程編程是最簡單和最流行的方法，但是還有另一種非常不同的技術，它可以讓你擁有多線程的幾乎所有優點，而無需實際使用多線程。 它僅僅在你的程序主要受 I/O 限制時有用，那么。 如果你的程序受處理器限制，那么先發制人的預定線程可能就是你真正需要的。 但是，網絡服務器很少受處理器限制。 如果你的操作系統在其 I/O 庫中支持 `select()` 系統調用（幾乎所有操作系統），那么你可以使用它來同時處理多個通信通道；在 I/O 正在“后臺”時進行其他工作。 雖然這種策略看起來很奇怪和復雜，特別是起初，它在很多方面比多線程編程更容易理解和控制。 [`asyncore`](#module-asyncore "asyncore: A base class for developing asynchronous socket handling services.") 模塊為您解決了許多難題，使得構建復雜的高性能網絡服務器和客戶端的任務變得輕而易舉。 對于“會話”應用程序和協議，伴侶 [`asynchat`](asynchat.xhtml#module-asynchat "asynchat: Support for asynchronous command/response protocols.") 模塊是非常寶貴的。 這兩個模塊背后的基本思想是創建一個或多個網絡 *通道* ，類的實例 [`asyncore.dispatcher`](#asyncore.dispatcher "asyncore.dispatcher") 和 [`asynchat.async_chat`](asynchat.xhtml#asynchat.async_chat "asynchat.async_chat") 。 創建通道會將它們添加到全局映射中，如果你不為它提供自己的 *映射* ，則由 [`loop()`](#asyncore.loop "asyncore.loop") 函數使用。 一旦創建了初始通道，調用 [`loop()`](#asyncore.loop "asyncore.loop") 函數將激活通道服務，該服務將一直持續到最后一個通道（包括在異步服務期間已添加到映射中的任何通道）關閉。 `asyncore.``loop`(\[*timeout*\[, *use\_poll*\[, *map*\[, *count*\]\]\]\])進入一個輪詢循環，其在循環計數超出或所有打開的通道關閉后終止。 所有參數都是可選的。 *count* 形參默認為 `None` ，導致循環僅在所有通道關閉時終止。 *timeout* 形參為適當的 [`select()`](select.xhtml#select.select "select.select") 或 [`poll()`](select.xhtml#select.poll "select.poll") 調用設置超時參數，以秒為單位; 默認值為30秒。 *use\_poll* 形參，如果為 True ，則表示 [`poll()`](select.xhtml#select.poll "select.poll") 應優先使用 `select`（默認為``False`()`）。 The *map* parameter is a dictionary whose items are the channels to watch. As channels are closed they are deleted from their map. If *map* is omitted, a global map is used. Channels (instances of [`asyncore.dispatcher`](#asyncore.dispatcher "asyncore.dispatcher"), [`asynchat.async_chat`](asynchat.xhtml#asynchat.async_chat "asynchat.async_chat") and subclasses thereof) can freely be mixed in the map. *class* `asyncore.``dispatcher`The [`dispatcher`](#asyncore.dispatcher "asyncore.dispatcher") class is a thin wrapper around a low-level socket object. To make it more useful, it has a few methods for event-handling which are called from the asynchronous loop. Otherwise, it can be treated as a normal non-blocking socket object. The firing of low-level events at certain times or in certain connection states tells the asynchronous loop that certain higher-level events have taken place. For example, if we have asked for a socket to connect to another host, we know that the connection has been made when the socket becomes writable for the first time (at this point you know that you may write to it with the expectation of success). The implied higher-level events are: Event 描述 `handle_connect()` Implied by the first read or write event `handle_close()` Implied by a read event with no data available `handle_accepted()` Implied by a read event on a listening socket During asynchronous processing, each mapped channel's [`readable()`](#asyncore.dispatcher.readable "asyncore.dispatcher.readable") and [`writable()`](#asyncore.dispatcher.writable "asyncore.dispatcher.writable") methods are used to determine whether the channel's socket should be added to the list of channels `select()`ed or `poll()`ed for read and write events. Thus, the set of channel events is larger than the basic socket events. The full set of methods that can be overridden in your subclass follows: `handle_read`()Called when the asynchronous loop detects that a `read()` call on the channel's socket will succeed. `handle_write`()Called when the asynchronous loop detects that a writable socket can be written. Often this method will implement the necessary buffering for performance. For example: ``` def handle_write(self): sent = self.send(self.buffer) self.buffer = self.buffer[sent:] ``` `handle_expt`()Called when there is out of band (OOB) data for a socket connection. This will almost never happen, as OOB is tenuously supported and rarely used. `handle_connect`()Called when the active opener's socket actually makes a connection. Might send a "welcome" banner, or initiate a protocol negotiation with the remote endpoint, for example. `handle_close`()Called when the socket is closed. `handle_error`()Called when an exception is raised and not otherwise handled. The default version prints a condensed traceback. `handle_accept`()Called on listening channels (passive openers) when a connection can be established with a new remote endpoint that has issued a [`connect()`](#asyncore.dispatcher.connect "asyncore.dispatcher.connect")call for the local endpoint. Deprecated in version 3.2; use [`handle_accepted()`](#asyncore.dispatcher.handle_accepted "asyncore.dispatcher.handle_accepted") instead. 3\.2 版后已移除. `handle_accepted`(*sock*, *addr*)Called on listening channels (passive openers) when a connection has been established with a new remote endpoint that has issued a [`connect()`](#asyncore.dispatcher.connect "asyncore.dispatcher.connect")call for the local endpoint. *sock* is a *new* socket object usable to send and receive data on the connection, and *addr* is the address bound to the socket on the other end of the connection. 3\.2 新版功能. `readable`()Called each time around the asynchronous loop to determine whether a channel's socket should be added to the list on which read events can occur. The default method simply returns `True`, indicating that by default, all channels will be interested in read events. `writable`()Called each time around the asynchronous loop to determine whether a channel's socket should be added to the list on which write events can occur. The default method simply returns `True`, indicating that by default, all channels will be interested in write events. In addition, each channel delegates or extends many of the socket methods. Most of these are nearly identical to their socket partners. `create_socket`(*family=socket.AF\_INET*, *type=socket.SOCK\_STREAM*)This is identical to the creation of a normal socket, and will use the same options for creation. Refer to the [`socket`](socket.xhtml#module-socket "socket: Low-level networking interface.") documentation for information on creating sockets. 在 3.3 版更改: *family* and *type* arguments can be omitted. `connect`(*address*)As with the normal socket object, *address* is a tuple with the first element the host to connect to, and the second the port number. `send`(*data*)Send *data* to the remote end-point of the socket. `recv`(*buffer\_size*)Read at most *buffer\_size* bytes from the socket's remote end-point. An empty bytes object implies that the channel has been closed from the other end. Note that [`recv()`](#asyncore.dispatcher.recv "asyncore.dispatcher.recv") may raise [`BlockingIOError`](exceptions.xhtml#BlockingIOError "BlockingIOError") , even though [`select.select()`](select.xhtml#select.select "select.select") or [`select.poll()`](select.xhtml#select.poll "select.poll") has reported the socket ready for reading. `listen`(*backlog*)Listen for connections made to the socket. The *backlog* argument specifies the maximum number of queued connections and should be at least 1; the maximum value is system-dependent (usually 5). `bind`(*address*)Bind the socket to *address*. The socket must not already be bound. (The format of *address* depends on the address family --- refer to the [`socket`](socket.xhtml#module-socket "socket: Low-level networking interface.") documentation for more information.) To mark the socket as re-usable (setting the `SO_REUSEADDR` option), call the [`dispatcher`](#asyncore.dispatcher "asyncore.dispatcher") object's `set_reuse_addr()` method. `accept`()Accept a connection. The socket must be bound to an address and listening for connections. The return value can be either `None` or a pair `(conn, address)` where *conn* is a *new* socket object usable to send and receive data on the connection, and *address* is the address bound to the socket on the other end of the connection. When `None` is returned it means the connection didn't take place, in which case the server should just ignore this event and keep listening for further incoming connections. `close`()Close the socket. All future operations on the socket object will fail. The remote end-point will receive no more data (after queued data is flushed). Sockets are automatically closed when they are garbage-collected. *class* `asyncore.``dispatcher_with_send`A [`dispatcher`](#asyncore.dispatcher "asyncore.dispatcher") subclass which adds simple buffered output capability, useful for simple clients. For more sophisticated usage use [`asynchat.async_chat`](asynchat.xhtml#asynchat.async_chat "asynchat.async_chat"). *class* `asyncore.``file_dispatcher`A file\_dispatcher takes a file descriptor or [file object](../glossary.xhtml#term-file-object) along with an optional map argument and wraps it for use with the `poll()`or `loop()` functions. If provided a file object or anything with a `fileno()` method, that method will be called and passed to the [`file_wrapper`](#asyncore.file_wrapper "asyncore.file_wrapper") constructor. [Availability](intro.xhtml#availability): Unix. *class* `asyncore.``file_wrapper`A file\_wrapper takes an integer file descriptor and calls [`os.dup()`](os.xhtml#os.dup "os.dup") to duplicate the handle so that the original handle may be closed independently of the file\_wrapper. This class implements sufficient methods to emulate a socket for use by the [`file_dispatcher`](#asyncore.file_dispatcher "asyncore.file_dispatcher") class. [Availability](intro.xhtml#availability): Unix. ## asyncore Example basic HTTP client Here is a very basic HTTP client that uses the [`dispatcher`](#asyncore.dispatcher "asyncore.dispatcher") class to implement its socket handling: ``` import asyncore class HTTPClient(asyncore.dispatcher): def __init__(self, host, path): asyncore.dispatcher.__init__(self) self.create_socket() self.connect( (host, 80) ) self.buffer = bytes('GET %s HTTP/1.0\r\nHost: %s\r\n\r\n' % (path, host), 'ascii') def handle_connect(self): pass def handle_close(self): self.close() def handle_read(self): print(self.recv(8192)) def writable(self): return (len(self.buffer) > 0) def handle_write(self): sent = self.send(self.buffer) self.buffer = self.buffer[sent:] client = HTTPClient('www.python.org', '/') asyncore.loop() ``` ## asyncore Example basic echo server Here is a basic echo server that uses the [`dispatcher`](#asyncore.dispatcher "asyncore.dispatcher") class to accept connections and dispatches the incoming connections to a handler: ``` import asyncore class EchoHandler(asyncore.dispatcher_with_send): def handle_read(self): data = self.recv(8192) if data: self.send(data) class EchoServer(asyncore.dispatcher): def __init__(self, host, port): asyncore.dispatcher.__init__(self) self.create_socket() self.set_reuse_addr() self.bind((host, port)) self.listen(5) def handle_accepted(self, sock, addr): print('Incoming connection from %s' % repr(addr)) handler = EchoHandler(sock) server = EchoServer('localhost', 8080) asyncore.loop() ``` ### 導航 - [索引](../genindex.xhtml "總目錄") - [模塊](../py-modindex.xhtml "Python 模塊索引") | - [下一頁](asynchat.xhtml "asynchat --- 異步 socket 指令/響應 處理器") | - [上一頁](selectors.xhtml "selectors --- 高級 I/O 復用庫") | -  - [Python](https://www.python.org/) ? - zh\_CN 3.7.3 [文檔](../index.xhtml) ? - [Python 標準庫](index.xhtml) ? - [網絡和進程間通信](ipc.xhtml) ? - $('.inline-search').show(0); | ? [版權所有](../copyright.xhtml) 2001-2019, Python Software Foundation. Python 軟件基金會是一個非盈利組織。 [請捐助。](https://www.python.org/psf/donations/) 最后更新于 5月 21, 2019. [發現了問題](../bugs.xhtml)？ 使用[Sphinx](http://sphinx.pocoo.org/)1.8.4 創建。