Python 3.6.5 Documentation >  "asyncio" — Asynchronous I/O, event loop, coroutines and tasks

"asyncio" — Asynchronous I/O, event loop, coroutines and tasks
**************************************************************

New in version 3.4.

**Source code:** Lib/asyncio/

======================================================================

This module provides infrastructure for writing single-threaded
concurrent code using coroutines, multiplexing I/O access over sockets
and other resources, running network clients and servers, and other
related primitives. Here is a more detailed list of the package
contents:

* a pluggable event loop with various system-specific
implementations;

* transport and protocol abstractions (similar to those in Twisted);

* concrete support for TCP, UDP, SSL, subprocess pipes, delayed
calls, and others (some may be system-dependent);

* a "Future" class that mimics the one in the "concurrent.futures"
module, but adapted for use with the event loop;

* coroutines and tasks based on "yield from" (**PEP 380**), to help
write concurrent code in a sequential fashion;

* cancellation support for "Future"s and coroutines;

* synchronization primitives for use between coroutines in a single
thread, mimicking those in the "threading" module;

* an interface for passing work off to a threadpool, for times when
you absolutely, positively have to use a library that makes blocking
I/O calls.

Asynchronous programming is more complex than classical “sequential”
programming: see the Develop with asyncio page which lists common
traps and explains how to avoid them. Enable the debug mode during
development to detect common issues.

Table of contents:

* Base Event Loop

* Run an event loop

* Calls

* Delayed calls

* Futures

* Tasks

* Creating connections

* Creating listening connections

* Watch file descriptors

* Low-level socket operations

* Resolve host name

* Connect pipes

* UNIX signals

* Executor

* Error Handling API

* Debug mode

* Server

* Handle

* Event loop examples

* Hello World with call_soon()

* Display the current date with call_later()

* Watch a file descriptor for read events

* Set signal handlers for SIGINT and SIGTERM

* Event loops

* Event loop functions

* Available event loops

* Platform support

* Windows

* Mac OS X

* Event loop policies and the default policy

* Event loop policy interface

* Access to the global loop policy

* Customizing the event loop policy

* Tasks and coroutines

* Coroutines

* Example: Hello World coroutine

* Example: Coroutine displaying the current date

* Example: Chain coroutines

* InvalidStateError

* TimeoutError

* Future

* Example: Future with run_until_complete()

* Example: Future with run_forever()

* Task

* Example: Parallel execution of tasks

* Task functions

* Transports and protocols (callback based API)

* Transports

* BaseTransport

* ReadTransport

* WriteTransport

* DatagramTransport

* BaseSubprocessTransport

* Protocols

* Protocol classes

* Connection callbacks

* Streaming protocols

* Datagram protocols

* Flow control callbacks

* Coroutines and protocols

* Protocol examples

* TCP echo client protocol

* TCP echo server protocol

* UDP echo client protocol

* UDP echo server protocol

* Register an open socket to wait for data using a protocol

* Streams (coroutine based API)

* Stream functions

* StreamReader

* StreamWriter

* StreamReaderProtocol

* IncompleteReadError

* LimitOverrunError

* Stream examples

* TCP echo client using streams

* TCP echo server using streams

* Get HTTP headers

* Register an open socket to wait for data using streams

* Subprocess

* Windows event loop

* Create a subprocess: high-level API using Process

* Create a subprocess: low-level API using subprocess.Popen

* Constants

* Process

* Subprocess and threads

* Subprocess examples

* Subprocess using transport and protocol

* Subprocess using streams

* Synchronization primitives

* Locks

* Lock

* Event

* Condition

* Semaphores

* Semaphore

* BoundedSemaphore

* Queues

* Queue

* PriorityQueue

* LifoQueue

* Exceptions

* Develop with asyncio

* Debug mode of asyncio

* Cancellation

* Concurrency and multithreading

* Handle blocking functions correctly

* Logging

* Detect coroutine objects never scheduled

* Detect exceptions never consumed

* Chain coroutines correctly

* Pending task destroyed

* Close transports and event loops

See also: The "asyncio" module was designed in **PEP 3156**. For a
motivational primer on transports and protocols, see **PEP 3153**.