Asynchronous programming in Python

ASYNCHRONOUS
PROGRAMMING IN
PYTHON
With Rocks In

Wednesday, 31 August, 11

Not really covering Tornado


Introduction to Asynchronous


Still intermediate


Just mostly Twisted


Just mostly Twisted
... with some Tornado.


Introductions

• Hi, I'm Aurynn

• This is a hedgehog


I’m more like a Magpie

• Shiny things are SO COOL

• I could talk about how
shiny they are until

http://www.ﬂickr.com/photos/cmg2011/5147250751/


Look! A particularly shiny thing!


Buzzword Bingo

• Much ado about Node.js

• Event Driven!

• Tornado, from Facebook!

• Event loops!

• “Web Scale!”


Lots of Chatter

• Without lots of research, it’s
just kind of noise

http://en.wikipedia.org/wiki/File:Carl_Friedrich_Gauss.jpg


Past the buzzwords, useful ideas


Asynchronous programming, or


Doing more than one thing at once


... sort of.


And it’s the sort of that is
important


A TERRIBLY BRIEF,
PROBABLY INACCURATE
HISTORY


Threading, you’ve heard of it

• Really common

• Java, .NET, even some
Python

• Super awesome! Shared
memory, shared scopes, fun
all around..


Surprisingly good, until it isn’t

• Very difﬁcult to access
shared state safely

• Race conditions

• Even experts have a hard
time of it

• Generally hard to do right


The kernel cares about when things happen, not you.

Multiprocessing No problems with locks or race conditions, since you
don’t have a consistent memory region

Fork() makes life so easy!

the MP model even makes multiple-systems a viable
approach: it’s pretty trivial to SSH into another
computer and run a program, or a batch of programs.

• Let the kernel care!

• Fairly easy to write MP
code on unix-likes

• Can even go multi-system

http://www.ﬂickr.com/photos/epw/2876377014/


Hard to share Data

• It’s not easy to send data
between processes

• Parsing stdout, or trying to
get a shmem
implementation working.

• import multiprocessing can
be.. quirky.


Asynchronous!

• Like threading, everything
is in a single process

• All my Variables, All the
Time

• No race conditions (mostly)

• Guarantee of no
concurrent execution

http://www.ﬂickr.com/photos/rachelpasch/3754315974/


Not all Unicorns and Rainbows
Just like MP and threads, event loops have their own caveats and major
constraints.

Your code can’t run indefinitely, and the longer it runs, the longer your process
stalls.

Like threading, it’s still Not Easy to get your head around how to write
asynchronous code, and this is something else we’ll go into in a bit more detail.

Single mistakes, not catching your errors in The Approved Way? You can very
easily trash your entire program and cause yourself to hang. Why does this
happen? It comes back to the first point of You Need to Let Go.
• You have to Let Go

• Bending your mind to the
Asynchronous Way is still
hard

• A single mistake can hang

• Probably going to be slower.

http://www.ﬂickr.com/photos/digitalpapercuts/5737975961


SO REALLY, WHAT IS ASYNC?
So, I’ve made some broad generalizations about event
loops, and the caveats they bring to the table.
Let’s go into some more detail about what they do and
are, and how those caveats actually work, and look at
some code to really show how to work in the
Asynchronous Way.


so, to get this far, we haven’t really
answered the first question:
what *is* an event loop?

What is an event loop?


What is an event loop? At its heart, an event loop is just a long-running
while loop, iterating over a set of callbacks, or
events to be run in the future.

When an event gets triggered, often in the form
of a socket message, or the completion of
another function, or a timeout firing.

• A long-running while loop

• When an event triggers, the loop catches this fact

• Events are pretty generic


Then what?


Then what? When you added the event you care about, you
also added a callback. A callback is simply a
Python function that gets run with the results
of the event.
The return value of a function, or the data
coming off your socket, or whatever is what
this function gets passed.

The great part is that this function definition is
allowed to be *any callable* object in Python. A
class with .__call__, a function, a bound method
on an object, whatever scope you like, it has.

• Let my code know!

• This code can be any callable


But once it’s in your code..


You have to Let Go As you’ve probably figured out, what happens in
an event system is analogous to co-operative
multitasking.
When an event fires and your callback gets run,
what happens?
Since it’s a standard method call,

Event Loop

Your Code


You have to Let Go control is handed over to your method, and
doesn’t return to the event loop UNTIL YOU
RETURN.

Event Loop

Your Code


We could be here a while... control is handed over to your method, and
doesn’t return to the event loop UNTIL YOU
RETURN.

So let’s say your particular callback takes, oh
second to do its thing, as it’s a particularly
computationally intensive, your entire event
loop is unable to do anything else.

Let’s compute Pi to
a BILLION decimal
places!

Your Code


Not just silly maths, either This happens no matter what your code does,
it silly math or a web site reaching out to
MySQL for data, or going to disk to open a file
iterating over a long array, or even waiting on
the user to do something.

As long as your code hasn’t returned, your ent
program has STALLED.

I need some data
from MySQL.

Your Code


You have STALLED.

http://www.ﬂickr.com/photos/neilwill/5023734329/


It should be fairly obvious that this is bad, and why it’s bad.

To use the example of a hypothetical website, if you’re stalled
waiting for the database, you can’t accept new connections,
and you can’t even give an indication why. Your site will
*appear* to perform slowly.

Is that really bad?


Solving this isn’t easy, and requires adjusting your mental
model on how programs flow.

In Twisted, programs have to be written with the idea that a
method call won’t return the results you expect, but instead
an object that will tell a function what your data is.

Asynchronous code is harder



For instance, x = y() won’t do what you expect.

How can it, when you’re not actually

• x = y() doesn’t work anymore.



In this model, you end up with very tiny
functions that perform very small, discrete
amounts of work, before releasing control back
to the event loop.

In order for these very tiny functions to be
useful, we have to keep tight control over our
scope, and an easy way to do that is by using
closures.

• x = y() doesn’t work anymore.

• Requires very tiny functions


This is what Twisted does As you can see here, we’ve expanded our row
processor into its own function, as well as adding
an error handler to the t wisted Deferred.


The first way in which asynchronous code can be written is
through the use of closures.

A closure is a funky sort of internal, anonymous function
that “closes over” the scope of the function it’s defined in.

This can be very powerful, as the closure effectively
“resumes” back in the middle of the original function, can
update state, and generally do useful things.

Wait, wait, what just happened?


What that was was a *deferred*, basically the core
response that you’ll get out of an API in Twisted.

What a deferred is, is an indicator that something is going to
happen *later on*, as opposed to right now.

This comes back to the core ideal of having to let go, and let’s
go back to the code to explain further

Deferred, the Core of Twisted


The Core of Twisted

• Most APIs built on Twisted return Deferreds

• Almost always involve user code





But what is a Deferred?


But what is it? These are the basic features that you probably care
about in a deferred;

Add callbacks and errbacks, which we’ve already
covered a bit of,

and these new methods, .callback and .errback.


For instance, x = y() won’t do what you expect.

Segue Power! How can it, when you’re not actually

• .callback starts the callback chain

• .errback causes the callback chain to explode and die
messily





errback is structurally identical to
callbacks


Let’s look at this again





What’s the key here?





It doesn’t happen right away.


Synchronous Example


And again, for comparison





Composition





Or, chaining callbacks


Wha?





Synchronous callback chain


ASYNCHRONOUS != FASTER
The final caveat on our List of Asynchronous Problems
is the idea I’ve run into that asynchronous code is, by
the very fact of running on an evented IO ser ver, it
will be faster.

This idea is all sorts of wrong.
Synchronous code that simply runs inside of a event-
driven IO system like Twisted or Tornado is naturally
going to be slower than the same code running
standalone.


Synchronous code that simply runs inside of a event-driven
IO system like Twisted or Tornado is naturally going to be
slower than the same code running standalone.

The event loop is overhead


And, as you’ve already seen on how to structure
asynchronous programs, effectively useless, unless you take
the time to program to take advantage of an asynchronous
event loop.

The event loop is overhead...

..and without proper coding, useless


The question you all want to ask


WHY BOTHER?
Why spend extra time doing it the Hard Way, the way
where you are required to do more work and write code
in completely new ways?


The real advantage, the real power of asynchronous
programming is the level of scale to which you can go.

No threads means no thread overhead, and no complexity of
maintaining locks and trying to share state.

Nginx, well-regarded as one of the fastest webser vers
around, is entirely built around asynchronous programming.

Scales beautifully


Once you really “get it”, the entire idea starts seeming
terribly elegant and worthwhile, and you start looking for
how to process code asynchronously in all aspects of your
programming.

Terribly elegant


You also end up in a position where you’re writing far more
reusable code.
Why? Well, you need to have these functions which run as
callbacks, and as we’ll go into in a little bit, those same
callbacks can be chained together. There’s very little point in
rewriting code all the time to

More re-usable code


What do I mean by this? Your code is often going to be
waiting for other servers - webser vers, database ser vers,
net work, file, Everything.

So the example I have the

Closer mapping to reality


LITTLE BITS OF TORNADOS
Since I’ve spent most of my time so far talking
about Twisted as opposed to the other “major”
asynchronous platform, I’d like to devote a little bit
of time to Tornado.


Tornado, while it does have an internal IO loop, and libraries
*do* use it standalone, the vast majority of examples you’ll
run across take the idea of it being a web framework akin to
Pylons or Pyramid or Bottle.

Event loop + web framework


Callbacks are inline


Not as wide library support


Lacks a deferred metaphor


Tornado, while it does have an internal IO loop, and libraries
*do* use it standalone, the vast majority of examples you’ll
run across take the idea of it being a web framework akin to
Pylons or Pyramid or Bottle.

.add_callback(my_function)


my_function has to handle both


my_function( response, error )


So why Tornado over Twisted?


Speed.
http://programmingzen.com/2009/09/13/benchmarking-tornado-vs-twisted-web-vs-tornado-on-twisted/


SO, THAT’S IT.


ANY QUESTIONS?


THANKS!


Asynchronous programming in Python

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (12)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Asynchronous programming in Python