Schedule the execution of a :ref:`coroutine <coroutine>`: wrap it in a

future. A task is a subclass of :class:`Future`.

the wrapped coroutine yields from a future, the task suspends the execution

of the wrapped coroutine and waits for the completition of the future. When

the future is done, the execution of the wrapped coroutine restarts with the

result or the exception of the future.

Event loops use cooperative scheduling: an event loop only runs one task at

running in different threads. While a task waits for the completion of a

future, the event loop executes a new task.

:meth:`cancel` will throw a :exc:`~concurrent.futures.CancelledError` to the

wrapped coroutine. :meth:`~Future.cancelled` only returns ``True`` if the

wrapped coroutine did not catch the

<coroutine>` did not complete. It is probably a bug and a warning is

logged: see :ref:`Pending task destroyed <asyncio-pending-task-destroyed>`.

function or the :meth:`BaseEventLoop.create_task` method.

.. classmethod:: all_tasks(loop=None)

.. method:: cancel()

This arranges for a :exc:`~concurrent.futures.CancelledError` to be

thrown into the wrapped coroutine on the next cycle through the event

loop. The coroutine then has a chance to clean up or even deny the

request using try/except/finally.

will be cancelled: the exception might be caught and acted upon, delaying

Immediately after this method is called, :meth:`~Future.cancelled` will

not return ``True`` (unless the task was already cancelled). A task will

This produces output similar to that of the traceback module, for the

frames retrieved by get_stack(). The limit argument is passed to

get_stack(). The file argument is an I/O stream to which the output

Example: Parallel execution of tasks