Qgelm

A simple introduction to Python’s asyncio – Hacker Noon

<html> <figure name=„6d7c“ id=„6d7c“ class=„graf graf–figure graf–leading“><div class=„aspectRatioPlaceholder is-locked c3“> <img class=„graf-image“ data-image-id=„1*R4HzblupF0U1sgfCqH9SUg.png“ data-width=„1280“ data-height=„589“ data-action=„zoom“ data-action-value=„1*R4HzblupF0U1sgfCqH9SUg.png“ src=„https://cdn-images-1.medium.com/max/1600/1*R4HzblupF0U1sgfCqH9SUg.png“/></div> </figure> <blockquote name=„c8f5“ id=„c8f5“ class=„graf graf–pullquote graf-after–h3“ readability=„4“> This is a no-buzzword first principles introduction to the asyncio library in Python. </blockquote> If you’ve come here, it is likely that you have heard of words such as asynchronous, concurrency and parallelism. Before we start off with asyncio, lets quickly get some basic things about these words right (via examples), so that we have a solid foundation to build this upon. Concurrency is like having two threads running on a single core CPU. Instructions from each thread could be interleaved, but at any given time, only one of the two threads is actively making progress. Parallelism is like having two threads running simultaneously on different cores of a multi-core CPU. <blockquote name=„8ce6“ id=„8ce6“ class=„graf graf–blockquote graf-after–p“ readability=„4“> It is important to note that parallelism implies concurrency but not the other way round. </blockquote> Asynchronous is a higher level programming concept, where you fire off some task, and decide that while you don’t have the result of that task, you are better off doing some other work instead of waiting. <blockquote name=„1825“ id=„1825“ class=„graf graf–blockquote graf-after–p“ readability=„7“> When you do things asynchronously, you are, by definition implying concurrency between those things. </blockquote> <h4 name=„6e25“ id=„6e25“ class=„graf graf–h4 graf-after–blockquote“>Why asynchronous programming?</h4> Why do we want to write asynchronous programs you say — because it could increase the performance of your program many many times. Imagine you have a single core machine you are running your app on. You receive a request, and you need to make two database queries to fulfil that request. Each query takes 50ms of time. With a synchronous program, you would make the second request only after completing the first — total time 100ms. With an asynchronous program, you could fire off both the queries one after the other — total time 50ms. <h3 name=„1363“ id=„1363“ class=„graf graf–h3 graf-after–p“>asyncio</h3> Asyncio is all about writing asynchronous programs in Python. Asyncio is a beautiful symphony between an Event loop, Tasks and Coroutines all coming together so perfectly — its going to make you cry. <h4 name=„3546“ id=„3546“ class=„graf graf–h4 graf-after–p“>The Event Loop</h4> This is what makes it all possible — a simple loop, thats it. Well not that simple. But here is how it works. The event loop is the orchestrator of the symphony. It runs tasks one after the other. At any given time, only one of the tasks is running. As you can imagine, there is a lot of pressure on the active task, since other tasks are waiting for their turn. So, when the active task makes a blocking call, say a network request, and cannot make further progress it gives the control back to the event loop realising that some other task could possibly better utilise the event loop’s time. It also tells the event loop what exactly it is blocked upon, so that when the network response comes, the event loop can consider giving it time to run again. <blockquote name=„656f“ id=„656f“ class=„graf graf–blockquote graf-after–p“ readability=„8“> The event loop time is precious. If you are not making progress, you should step off the loop, so that someone else can. Event loop is the measure of progress. </blockquote> <h4 name=„b11e“ id=„b11e“ class=„graf graf–h4 graf-after–blockquote“>The Coroutine & Task</h4> Coroutines (co-operative routines) are a key element of the symphony. It is the coroutines, and their co-operative nature, that enables giving up control of the event loop, when the coroutine has nothing useful to do. A coroutine is a stateful generalisation of the concept of subroutine. A subroutine is your good old-fashioned function or method. You invoke the subroutine to perform a computation. You may invoke it again, but it does not hold state between the two invocations. Every invocation is a fresh one and same computation is performed. A coroutine, on the other hand, is a cute little stateful widget. It looks like a subroutine, but it maintains state in between executions. In other words, when a coroutine “returns” (yields control) it simply means that it has paused its execution (with some saved state). So when you “invoke” (give control to) the coroutine subsequently, it would be correct to say that the coroutine has resumed its execution (from the saved state). <blockquote name=„e254“ id=„e254“ class=„graf graf–blockquote graf-after–p“ readability=„6“> Coroutines look like a normal function, but in their behaviour they are stateful objects with

markup--blockquote-code"

resume()

and

markup--blockquote-code"

pause()

— like methods. </blockquote> In Python 3.5+, the way a coroutine pauses itself is using the

markup--p-code"

await

keyword. Inside a coroutine, when you

markup--p-code"

await

on another coroutine, you step off the event loop and schedule the awaited coroutine to run immediately. That is, an

markup--p-code"

await other_coroutine

inside a coroutine will pause it, and schedule the coroutine

markup--p-code"

other_coroutine

to run immediately. <blockquote name=„0dc5“ id=„0dc5“ class=„graf graf–blockquote graf-after–p“ readability=„4“> Note that the event loop does not preempt a running coroutine. Only a coroutine can pause itself. </blockquote> Below is a very simple example (Python 3.5+) of how coroutines cooperate with each other. We will use a pre-defined coroutine

markup--p-code"

asyncio.sleep

to help us simulate blocking tasks for this example, but it could be anything in a real world scenario like a network request, db query etc. Note that the code runs in a single thread and yet, the output will have interleaved print statements. This happens because when a coroutine gets blocked, it steps off the loop, so that the other one can run (yay! asynchronous programming with asyncio). <figure name=„977e“ id=„977e“ class=„graf graf–figure graf–iframe graf-after–p“> <figcaption class=„imageCaption“>python run coroutine_example.py</figcaption></figure>Some points to note <ul class=„postList“><li name=„05d5“ id=„05d5“ class=„graf graf–li graf-after–p“>Calling a coroutine definition does not execute it. It initialises a coroutine object. You

Qgelm

Seiten-Werkzeuge

Webseiten-Werkzeuge

Benutzer-Werkzeuge

A simple introduction to Python’s asyncio – Hacker Noon