Concurrency in Python

Is Python's Global Interpreter Lock slowing you down? Learn when to use multiprocessing or asyncio to unlock true parallel performance.

#1about 4 minutes

Defining concurrency, parallelism, and multitasking

Key terms like concurrency, parallelism, cooperative multitasking, and preemptive multitasking are defined to build a foundational understanding.

#2about 3 minutes

Weighing the benefits and complexity of multitasking

Multitasking can improve performance and reduce costs, but it introduces complexity, non-determinism, and is limited by Amdahl's Law.

#3about 5 minutes

Understanding the differences between processes and threads

Processes are isolated with higher overhead, while threads are lightweight and share memory, with examples using Python's `threading` and `multiprocessing` modules.

#4about 1 minute

Simplifying concurrency with executor pools

The `concurrent.futures` module provides a high-level interface with `ThreadPoolExecutor` and `ProcessPoolExecutor` to easily apply a function to multiple data items.

#5about 5 minutes

How to prevent data corruption with locks

Race conditions occur when multiple threads access shared data simultaneously, which can be prevented by using a mutex or `threading.Lock` to ensure exclusive access.

#6about 2 minutes

How Python's global interpreter lock affects multithreading

The GIL is a mutex that protects access to Python objects, preventing multiple native threads from executing Python bytecodes at the same time and impacting CPU-bound tasks.

#7about 4 minutes

Overcoming thread limitations with event-driven programming

The C10k problem highlights the inefficiency of a thread-per-client model, leading to event-driven solutions like asynchronous programming to handle many concurrent connections.

#8about 5 minutes

Writing concurrent code with async and await

Python's `async` and `await` keywords enable cooperative multitasking, allowing you to run many tasks concurrently on a single thread using an event loop from the `asyncio` module.

#9about 2 minutes

Building high-performance web services with Starlette

The Starlette web framework demonstrates how `asyncio` can be used to build highly concurrent web servers capable of handling many clients efficiently.

#10about 2 minutes

Q&A on Python's speed and choosing thread counts

Answers to common questions address Python's perceived slowness by working around limitations like the GIL and explain that benchmarking is key to finding the optimal number of threads.

From learning to earning

Jobs that call for the skills explored in this talk.