Understanding Python’s asyncio

Understanding Python’s asyncio:

Python

How to get started using Python’s asyncio.

Earlier this year, I attended PyCon, the international Python
conference. One topic, presented at numerous talks and discussed
informally in the hallway, was the state of threading in Python—which
is, in a nutshell, neither ideal nor as terrible as some critics would
argue.

A related topic that came up repeatedly was that of “asyncio”, a
relatively new approach to concurrency in Python. Not only were there
formal presentations and informal discussions about asyncio, but a
number of people also asked me about courses on the subject.

I must admit, I was a bit surprised by all the interest. After
all, asyncio isn’t a new addition to Python; it’s been around for a
few years. And, it doesn’t solve all of the problems associated with
threads. Plus, it can be confusing for many people to get started with it.

And yet, there’s no denying that after a number of years when
people ignored asyncio, it’s starting to gain steam. I’m sure
part of the reason is that asyncio has matured and improved over time,
thanks in no small part to much dedicated work by countless developers.
But, it’s also because asyncio is an increasingly good and useful choice
for certain types of tasks—particularly tasks that work across
networks.

So with this article, I’m kicking off a series on asyncio—what it is, how to
use it, where it’s appropriate, and how you can and should (and also can’t
and shouldn’t) incorporate it into your own work.

What Is asyncio?

Everyone’s grown used to computers being able to do more than one thing at a
time—well, sort of. Although it might seem as though computers are
doing more than one thing at a time, they’re actually switching, very
quickly, across different tasks. For example, when you ssh in to a Linux
server, it might seem as though it’s only executing your commands. But
in actuality, you’re getting a small “time slice” from the CPU, with the
rest going to other tasks on the computer, such as the systems that
handle networking, security and various protocols. Indeed, if you’re
using SSH to connect to such a server, some of those time slices
are being used by sshd to handle your connection and even allow you to
issue commands.

All of this is done, on modern operating systems, via “pre-emptive
multitasking”. In other words, running programs aren’t given a choice of
when they will give up control of the CPU. Rather, they’re forced to
give up control and then resume a little while later. Each process
running on a computer is handled this way. Each process can, in turn,
use threads, sub-processes that subdivide the time slice given to their
parent process.

via Linux Journal – The Original Magazine of the Linux Community