Simon Willison's Weblog: concurrency

From Async/Await to Virtual Threads

2025-08-03T18:57:56+00:00

Armin Ronacher has long been critical of async/await in Python, both for necessitating colored functions and because of the more subtle challenges they introduce like managing back pressure.

Armin argued convincingly for the threaded programming model back in December. Now he's expanded upon that with a description of how virtual threads might make sense in Python.

Virtual threads behave like real system threads but can vastly outnumber them, since they can be paused and scheduled to run on a real thread when needed. Go uses this trick to implement goroutines which can then support millions of virtual threads on a single system.

Python core developer Mark Shannon started a conversation about the potential for seeing virtual threads to Python back in May.

Assuming this proposal turns into something concrete I don't expect we will see it in a production Python release for a few more years. In the meantime there are some exciting improvements to the Python concurrency story - most notably around sub-interpreters - coming up this year in Python 3.14.

Tags: armin-ronacher, concurrency, gil, go, python, threads

This month in Servo: parallel tables and more

2024-07-31T15:03:28+00:00

This month in Servo: parallel tables and more

New in Servo:

Parallel table layout is now enabled (@mrobinson, #32477), spreading the work for laying out rows and their columns over all available CPU cores. This change is a great example of the strengths of Rayon and the opportunistic parallelism in Servo's layout engine.

The commit landing the change is quite short, and much of the work is done by refactoring the code to use .par_iter().enumerate().map(...) - par_iter() is the Rayon method that allows parallel iteration over a collection using multiple threads, hence multiple CPU cores.

Via Phoronix

Tags: concurrency, html, rust, servo

Free-threaded CPython is ready to experiment with!

2024-07-12T23:42:46+00:00

Free-threaded CPython is ready to experiment with!

The Python 3.13 beta releases that include a "free-threaded" version that removes the GIL are now available to test! A team from Quansight Labs, home of the PyData core team, just launched py-free-threading.github.io to help document the new builds and track compatibility with Python's larger ecosystem.

Free-threading mode will not be enabled in Python installations by default. You can install special builds that have the option enabled today - I used the macOS installer and, after enabling the new build in the "Customize" panel in the installer, ended up with a /usr/local/bin/python3.13t binary which shows "Python 3.13.0b3 experimental free-threading build" when I run it.

Here's my TIL describing my experiments so far installing and running the 3.13 beta on macOS, which also includes a correction to an embarrassing bug that Claude introduced but I failed to catch!

Tags: concurrency, gil, python, threads

Real Multithreading is Coming to Python - Learn How You Can Use It Now

2023-05-15T19:42:39+00:00

Real Multithreading is Coming to Python - Learn How You Can Use It Now

Martin Heinz provides a detailed tutorial on trying out the new Per-Interpreter GIL feature that’s landing in Python 3.12, which allows Python code to run concurrently in multiple threads by spawning separate sub-interpreters, each with their own dedicated GIL.

It’s not an easy feature to play with yet! First you need to compile Python yourself, and then use APIs that are generally only available to C code (but should hopefully become available to Python code itself in Python 3.13).

Martin’s workaround for this is ingenious: it turns out the Python test.support package provides utility functions to help write tests against interpreters, and Martin shows how to abuse this module to launch, run and cleanup interpreters using regular Python code.

He also demonstrates test.support.interpreters.create_channel(), which can be used to create channels with receiver and sender ends, somewhat similar to Go.

Via lobste.rs

Tags: concurrency, gil, go, python

PEP 554 – Multiple Interpreters in the Stdlib: Shared data

2022-09-20T01:25:51+00:00

PEP 554 – Multiple Interpreters in the Stdlib: Shared data

Python 3.12 hopes to introduce multiple interpreters as part of the Python standard library, so Python code will be able to launch subinterpreters, each with their own independent GIL. This will allow Python code to execute on multiple CPU cores at the same time while ensuring existing code (and C modules) that rely on the GIL continue to work.

The obvious question here is how data will be shared between those interpreters. This PEP proposes a channels mechanism, where channels can be used to send just basic Python types between interpreters: None, bytes, str, int and channels themselves (I wonder why not floats?)

Via theandrewbailey on Hacker News

Tags: concurrency, pep, python

The GIL and its effects on Python multithreading

2021-09-29T17:23:15+00:00

The GIL and its effects on Python multithreading

Victor Skvortsov presents the most in-depth explanation of the Python Global Interpreter Lock I’ve seen anywhere. I learned a ton from reading this.

Via Hacker News

Tags: concurrency, gil, python, threads

Can Scala gain wider usage than Java any time soon?

2012-02-11T17:17:00+00:00

My answer to Can Scala gain wider usage than Java any time soon? on Quora

No, because Scala is harder to master than Java.

(By "master" I mean get to the point where you can read and understand code written by someone else, no matter what language features and idioms they are using)

Tags: concurrency, java, programming, scala, scaling, web-development, quora

What server do I need to handle 1000+ users simultaneously while they can post messages, upload pictures, and other similar stuff on a website based on PHP and mySQL?

2012-01-10T09:37:00+00:00

My answer to What server do I need to handle 1000+ users simultaneously while they can post messages, upload pictures, and other similar stuff on a website based on PHP and mySQL? on Quora

You don't need to handle 1,000 users simultaneously: you need to build something and ship it and start the process of discovering what you can build that will attract that many users. Seriously: don't even start worrying about that kind of scale until you know you're going to need it.

(That said, there's no harm in keeping scaling issues in mind while you're building the software - try to avoid making dumb architectural decisions that will be impossible to scale later. But deciding on your 1,000+ simultaneous user serving architecture before you've Built Something People Want is a huge waste of your time).

Tags: concurrency, nodejs, tornado, webservers, quora

Distributed lock on top of memcached

2010-02-01T10:15:02+00:00

Distributed lock on top of memcached

A simple Python context manager (taking advantage of the with statement) that implements a distributed lock using memcached to store lock state: “memcached_lock can be used to ensure that some global data is only updated by one server”. Redis would work well for this kind of thing as well.

Tags: concurrency, contextmanager, locking, memcached, plurk, python, redis, with

dustin's gomemcached

2009-11-13T15:13:45+00:00

dustin's gomemcached

A memcached server written in Go, an experiment by memcached maintainer Dustin Sallings.

Via Hello World in Go

Tags: concurrency, dustin-sallings, go, memcached, programming

The Go Programming Language

2009-11-11T07:00:21+00:00

The Go Programming Language

A brand new systems programming language, designed by Robert Griesemer and Unix/Plan 9 veterans Rob Pike and Ken Thompson and funded by Google. Concurrency is supported by lightweight communicating processes called goroutines. “It feels like a dynamic language but has the speed and safety of a static language.”

Tags: concurrency, go, google, goroutines, ken-thompson, plan9, programming, robert-griesemer, rob-pike, unix

Testing Django Views for Concurrency Issues

2009-05-27T10:01:08+00:00

Testing Django Views for Concurrency Issues

Neat decorator for executing a Django view under high concurrency in your unit tests, to help spot errors caused by database race conditions that should be executed inside a transaction.

Tags: concurrency, django, python, raceconditions, testing, threads

A Curious Course on Coroutines and Concurrency

2009-04-24T10:58:42+00:00

A Curious Course on Coroutines and Concurrency

David Beazley’s sequel to last year’s mind-expanding “Generator Tricks for System Programmers”, perfect for if you’ve ever puzzled over what exactly you can use Python’s generator-based coroutine support for.

Tags: concurrency, coroutines, david-beazley, generators, python

django-springsteen and Distributed Search

2009-02-25T22:28:25+00:00

django-springsteen and Distributed Search

Will Larson’s Django search library currently just talks to Yahoo! BOSS, but is designed to be extensible for other external search services. Interestingly, it uses threads to fire off several HTTP requests in parallel from within the Django view.

Tags: concurrency, django, djangospringsteen, http, python, search, threads, will-larson, yahoo-boss

Mac OS X Leopard: Multicore

2007-06-11T23:02:07+00:00

Mac OS X Leopard: Multicore

“... NSOperation, a breakthrough new API that optimizes applications for the world of multicore processing.”

Tags: concurrency, leopard, macos, multicore, nsoperation