class asyncio.Task(coro, *, loop=None)
Schedule the execution of a coroutine: wrap it in a future. A task is a subclass of Future
.
A task is responsible for executing a coroutine object in an event loop. If 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 a time. Other tasks may run in parallel if other event loops are running in different threads. While a task waits for the completion of a future, the event loop executes a new task.
The cancellation of a task is different from the cancelation of a future. Calling cancel()
will throw a CancelledError
to the wrapped coroutine. cancelled()
only returns True
if the wrapped coroutine did not catch the CancelledError
exception, or raised a CancelledError
exception.
If a pending task is destroyed, the execution of its wrapped coroutine did not complete. It is probably a bug and a warning is logged: see Pending task destroyed.
Don’t directly create Task
instances: use the ensure_future()
function or the AbstractEventLoop.create_task()
method.
This class is not thread safe.
-
classmethod all_tasks(loop=None)
-
Return a set of all tasks for an event loop.
By default all tasks for the current event loop are returned.
-
classmethod current_task(loop=None)
-
Return the currently running task in an event loop or
None
.By default the current task for the current event loop is returned.
None
is returned when called not in the context of aTask
.
-
cancel()
-
Request that this task cancel itself.
This arranges for a
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.Unlike
Future.cancel()
, this does not guarantee that the task will be cancelled: the exception might be caught and acted upon, delaying cancellation of the task or preventing cancellation completely. The task may also return a value or raise a different exception.Immediately after this method is called,
cancelled()
will not returnTrue
(unless the task was already cancelled). A task will be marked as cancelled when the wrapped coroutine terminates with aCancelledError
exception (even ifcancel()
was not called).
-
get_stack(*, limit=None)
-
Return the list of stack frames for this task’s coroutine.
If the coroutine is not done, this returns the stack where it is suspended. If the coroutine has completed successfully or was cancelled, this returns an empty list. If the coroutine was terminated by an exception, this returns the list of traceback frames.
The frames are always ordered from oldest to newest.
The optional limit gives the maximum number of frames to return; by default all available frames are returned. Its meaning differs depending on whether a stack or a traceback is returned: the newest frames of a stack are returned, but the oldest frames of a traceback are returned. (This matches the behavior of the traceback module.)
For reasons beyond our control, only one stack frame is returned for a suspended coroutine.
-
print_stack(*, limit=None, file=None)
-
Print the stack or traceback for this task’s coroutine.
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 is written; by default output is written to sys.stderr.
Please login to continue.