Simon Willison's Weblog: threads

Quoting Kumar Aditya

2025-09-11T03:07:16+00:00

In Python 3.14, I have implemented several changes to fix thread safety of asyncio and enable it to scale effectively on the free-threaded build of CPython. It is now implemented using lock-free data structures and per-thread state, allowing for highly efficient task management and execution across multiple threads. In the general case of multiple event loops running in parallel, there is no lock contention and performance scales linearly with the number of threads. [...]

For a deeper dive into the implementation, check out the internal docs for asyncio.

— Kumar Aditya, Scaling asyncio on Free-Threaded Python

Tags: async, gil, python, scaling, threads

Hypothesis is now thread-safe

2025-08-08T22:08:55+00:00

Hypothesis is now thread-safe

Hypothesis is a property-based testing library for Python. It lets you write tests like this one:

from hypothesis import given, strategies as st

@given(st.lists(st.integers()))
def test_matches_builtin(ls):
    assert sorted(ls) == my_sort(ls)

This will automatically create a collection of test fixtures that exercise a large array of expected list and integer shapes. Here's a Gist demonstrating the tests the above code will run, which include things like:

[]
[0]
[-62, 13194]
[44, -19562, 44, -12803, -24012]
[-7531692443171623764, -109369043848442345045856489093298649615]

Hypothesis contributor Liam DeVoe was recently sponsored by Quansight to add thread safety to Hypothesis, which has become important recently due to Python free threading:

While we of course would always have loved for Hypothesis to be thread-safe, thread-safety has historically not been a priority, because running Hypothesis tests under multiple threads is not something we see often.

That changed recently. Python---as both a language, and a community---is gearing up to remove the global interpreter lock (GIL), in a build called free threading. Python packages, especially those that interact with the C API, will need to test that their code still works under the free threaded build. A great way to do this is to run each test in the suite in two or more threads simultaneously. [...]

Nathan mentioned that because Hypothesis is not thread-safe, Hypothesis tests in community packages have to be skipped when testing free threaded compatibility, which removes a substantial battery of coverage.

Now that Hypothesis is thread-safe another blocker to increased Python ecosystem support for free threading has been removed!

Via lobste.rs

Tags: gil, python, testing, threads

From Async/Await to Virtual Threads

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

From Async/Await to Virtual Threads

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

How we think about Threads’ iOS performance

2024-12-29T21:45:14+00:00

How we think about Threads’ iOS performance

This article by Dave LaMacchia and Jason Patterson provides an incredibly deep insight into what effective performance engineering looks like for an app with 100s of millions of users.

I always like hearing about custom performance metrics with their own acronyms. Here we are introduced to %FIRE - the portion of people who experience a frustrating image-render experience (based on how long an image takes to load after the user scrolls it into the viewport), TTNC (time-to-network content) measuring time from app launch to fresh content visible in the feed and cPSR (creation-publish success rate) for how often a user manages to post content that they started to create.

This article introduced me to the concept of a boundary test, described like this:

A boundary test is one where we measure extreme ends of a boundary to learn what the effect is. In our case, we introduced a slight bit of latency when a small percentage of our users would navigate to a user profile, to the conversion view for a post, or to their activity feed.

This latency would allow us to extrapolate what the effect would be if we similarly improved how we delivered content to those views.

[...]

We learned that iOS users don’t tolerate a lot of latency. The more we added, the less often they would launch the app and the less time they would stay in it. With the smallest latency injection, the impact was small or negligible for some views, but the largest injections had negative effects across the board. People would read fewer posts, post less often themselves, and in general interact less with the app. Remember, we weren’t injecting latency into the core feed, either; just into the profile, permalink, and activity.

There's a whole lot more in there, including details of their custom internal performance logger (SLATE, the “Systemic LATEncy” logger) and several case studies of surprising performance improvements made with the assistance of their metrics and tools, plus some closing notes on how Swift concurrency is being adopted throughout Meta.

Via Rafe Colburn

Tags: performance, threads, ios, meta, swift

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

Threads has entered the fediverse

2024-03-22T20:15:20+00:00

Threads has entered the fediverse

Threads users with public profiles in certain countries can now turn on a setting which makes their posts available in the fediverse—so users of ActivityPub systems such as Mastodon can follow their accounts to subscribe to their posts.

It’s only a partial integration at the moment: Threads users can’t themselves follow accounts from other providers yet, and their notifications will show them likes but not boosts or replies: “For now, people who want to see replies on their posts on other fediverse servers will have to visit those servers directly.”

Depending on how you count, Mastodon has around 9m user accounts of which 1m are active. Threads claims more than 130m active monthly users. The Threads team are developing these features cautiously which is reassuring to see—a clumsy or thoughtless integration could cause all sorts of damage just from the sheer scale of their service.

Via Gavin Anderegg

Tags: facebook, threads, mastodon, activitypub, fediverse

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

How we found and fixed a rare race condition in our session handling

2021-03-18T23:06:00+00:00

How we found and fixed a rare race condition in our session handling

GitHub had a terrifying bug this month where a user reported suddenly being signed in as another user. This is a particularly great example of a security incident report, explaining how GitHub identified the underlying bug, what caused it and the steps they are taking to ensure bugs like that never happen in the future. The root cause was a convoluted sequence of events which could cause a Ruby Hash to be accidentally shared between two requests, caused as a result of a new background thread that was introduced as a performance optimization.

Tags: github, security, threads

Weeknotes: Datasette Writes

2020-02-26T06:34:46+00:00

As discussed previously, the biggest hole in Datasette's feature set at the moment involves writing to the database.

Datasette was born as a hack to abuse serverless, stateless hosting by bundling a static, immutable database as part of the deployment. The key idea was that for some use-cases - such as data journalism - you don't need to be able to continually update your data. It's just the facts that support the story you are trying to tell.

I also believed the conventional wisdom that SQLite is fine for reads but shouldn't be trusted to handle web application writes. I no longer believe this to be the case: SQLite is great at handling writes, as millions of iPhone and Android apps will attest.

Meanwhile, the biggest blocker to people trying out Datasette is that they would need to convert their data to SQLite somehow in order to use it. I've been building a family of CLI tools for this, but that requires users to both be familiar with the command-line and to install software on their computers.

So: Datasette needs to grow web-based tools for loading data into the database.

Datasette's plugin system is the ideal space for experimenting with ways of doing this, without needing to try out crazy new features on Datasette's own core.

There's just one big problem: SQLite may be great at fast, reliable writes but it still doesn't like concurrent writes: it's important to only ever have one connection writing to a SQLite database at a time.

I've been mulling over the best way to handle this for the best part of a year... and then a couple of days ago I had a breakthrough: with a dedicated write thread for a database file, I could use a Python queue to ensure only one write could access the database at a time.

There's prior art for this: SQLite wizard Charles Leifer released code plus a beautiful explanation of how to queue writes to SQLite back in 2017. I'm not sure why I didn't settle on his approach sooner.

So... Datasette 0.37, released this evening, has a new capability exposed to plugins: they can now request that an operation (either a SQL statement or a full custom Python function) be queued up to execute inside a thread that posesses an exclusive write connection to a SQLite database.

I've documented how plugins can use this in the new plugin internals documentation: execute_write() and execute_write_fn().

So far there's only one public plugin that takes advantage of this: datasette-upload-csvs, which previously used a dirty hack but has now been upgraded to use the new execute_write_fn() method.

I'm really excited about the potential plugins this unlocks though. I experimented with a logging plugin and a plugin for deleting tables while I was building the hooks (full implementations of those are posted as comments in the pull request).

Other use-cases I'm interested to explore include:

Plugins that import data from other APIs or services. Imagine web UI interfaces to some of my Dogsheep tools for example.
Plugins that periodically update data - pulling the latest CSV updates from government open data portals (like San Francisco's trees).
Tools for enhancing tables with additional data derived from their values - geocoding or reverse geocoding columns, resolving identifiers and so on.
Now that plugins have a tool for maintaining their own state, plugins could use SQLite tables to track things like which saved searches have been executed.
A plugin that lets you attach annotations to rows and columns in other tables, storing those annotations in its own SQLite database.

Tags: csv, plugins, sqlite, threads, datasette, weeknotes

An Intro to Threading in Python

2019-04-18T05:24:24+00:00

An Intro to Threading in Python

Real Python consistently produces really comprehensive, high quality articles and tutorials. This is an excellent introduction to threading in Python, covering threads, locks, queues, ThreadPoolExecutor and more.

Via @realpython

Tags: python, threads

Intro to Threads and Processes in Python

2018-04-19T18:32:24+00:00

Intro to Threads and Processes in Python

I really like the diagrams in this article which compares the performance of Python threads and processes for different types of task via the excellent concurrent.futures library.

Via Gergely Szerovay

Tags: multiprocessing, python, threads

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

Introducing Yardbird

2009-05-22T23:13:39+00:00

Introducing Yardbird

I absolutely love it—an IRC bot built on top of Twisted that passes incoming messages off to Django code running in a separate thread. Requests and Response objects are used to represent incoming and outgoing messages, and Django’s regex-based URL routing is used to dispatch messages to different handling functions based on their content.

Tags: django, irc, regular-expressions, threads, twisted, yardbird

Using Scala with Google App Engine

2009-04-11T15:28:48+00:00

Using Scala with Google App Engine

Scala works, but I haven’t seen confirmation on actors yet (which are likely to break due to their dependency on threads).

Tags: google, google-app-engine, java, scala, threads

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

jessenoller.com - python magazine

2009-02-05T23:10:43+00:00

jessenoller.com - python magazine

Jesse Noller has been sharing his articles originally published in Python Magazine. Topics include SSH programming with Paramiko, context managers and the with statement and an excellent explanation of Python’s threading support and the global interpreter lock.

Tags: contextmanagers, gil, jesse-noller, paramiko, python, pythonmagazine, ssh, threads

Thread Synchronization Mechanisms in Python

2007-07-29T21:32:01+00:00

Thread Synchronization Mechanisms in Python

Locks, RLocks, Semaphores, Events and Conditions as explained by Fredrik Lundh.

Tags: conditions, effbot, events, fredrik-lundh, locks, python, rlocks, semaphores, threads, tutorial

Quoting Guido van Rossum

2007-05-08T21:21:30+00:00

Just because Java was once aimed at a set-top box OS that didn't support multiple address spaces, and just because process creation in Windows used to be slow as a dog, doesn't mean that multiple processes (with judicious use of IPC) aren't a much better approach to writing apps for multi-CPU boxes than threads.

— Guido van Rossum

Tags: guido-van-rossum, ipc, java, python, threads, windows