Transcript

Alright, let's talk about Python concurrency. If you've ever wanted to make your code run faster, this is for you. We're going to breakdown the three main ways Python handles doing multiple things at once so you can write much more efficient code. So here's the game plan. First, we'll look at the problem, the old school way of doing things. Then we'll get into the two types of work your code can do. After that, we'll reveal the one single factor that changes absolutely everything. And finally, we'll put the three solutions head-to-head so you know exactly which one to pick. OK, so First things first. Let's set the stage by looking at the problem we're all trying to solve. That standard, one line at a time code that can feel painfully slow. Now this is a pretty perfect way to think about it. Synchronous code is exactly like this one poor worker. Your entire program is stuck on one single task, completely frozen until that task is done before I can even think about starting the next one. You know, this looks simple, and it makes sense. You start task A, you wait. Then you start task B, and you wait. But the moment one of those tasks involves waiting for something out of its control, like a network request or saving a big file, your whole program just grinds to a halt. So how do we fix this slog? Well, the key, the real key to picking the right tool for the job is to 1st understand what kind of work your program is actually doing. And this is where it gets really interesting. See, pretty much every task your program ever does falls into one of these two buckets. It's either CPU bound, meaning it's limited by how fast your processor can crunch numbers, or it's IO bound, meaning it's limited by how long it has to wait for something else. This single distinction changes. Everything. And that difference between waiting and computing, Well, it leads us directly to the single most important and honestly the most misunderstood concept in all of Python, concurrency. You probably asked yourself this exact question, right? I have an 8 core CPU. Why can I just throw 8 threads in my problem and make it go 8 times faster? It's a great question, and the answer is a powerful three letter acronym, the Jill. So what on earth is the Gil? The Global Interpreter Lock? You can think of it like a strict. Traffic cop that stands in front of all your Python objects. Its main purpose, its reason for existing, is to protect Python's memory and keep things from getting corrupted. And it does this by enforcing one simple rule. Only one thread gets to run Python code at any given time. That's it. So even with a monster 16 core processor, the GL ensures only one core is running your Python code at once. And that's the big take away for heavy duty number crunching. The GL basically turns your multithreaded program into a single threaded. Now, it's not all bad. The Gil makes Python's memory management simpler and makes it easier to work with C libraries. It's a tradeoff. But, and this is pretty exciting, there is a major effort underway to make the Gil optional in future versions of Python. For now, though, it's the reality we have to design our programs around. OK, so now that we understand the big boss, the Jill, let's meet our three contenders. We're going to see how each one is designed to either work with the Jill or get around it completely. First up to the plate is threading. This is the classic old school approach for speeding up programs that spend a lot of their time just waiting around. Threading is the perfect tool for those IO bound tasks we talked about. It gives you this fantastic illusion that multiple things are happening at the exact same time. But because of the Jill, it's actually more like an expert juggler than a true team of workers. And this is the magic trick. This is how threading works. Its magic when one of your threads is just sitting there waiting for a file. Download or database to respond. It does something very polite. It releases the geel. It basically says hey I'm not using the CPU, somebody else can have a turn and that's how it works. Threading is all about using that dead weight time effectively. OK, fine, But what if your program isn't waiting? What if it's all about heavy lifting, pure computation with no downtime? Well, that is a job for a completely different tool. That's a job for multiprocessing. Right, If threading is 1 worker juggling a bunch of tasks, multiprocessing is like hiring a whole new team of miners and giving each one their own mind shaft. It completely avoids the GL problem by creating brand new separate processes. Each process gets its own Python interpreter, its own memory, and here's the key, its own Gil. This is how you finally achieve true parallelism and light up all those CPU cores at the same time. And that brings us to our third and final contender, async IO. This is the modern, slick and super efficient way to handle a massive number of IO bound tasks. You can think of async IO as a master conductor who is incredibly fast. It all happens on a single thread, but it's brilliant at juggling. Instead of creating a whole new operating system thread for every little task, it uses something called an event loop to switch between tasks at lightning speed. This makes it insanely lightweight and scalable, perfect for something like a web server that's handling thousands of connections at once. OK, we've met the players Threading, multiprocessing and async IO O. How in the world do you actually choose the right one for your project? Well, this table is basically your CHEAT SHEET. Let's break it down. Is your code CPU bound? Are you doing heavy math or data processing? It's simple. Multiprocessing is your only choice. It's the only way to get true parallelism. Now if your code is mostly waiting, if it's IO bound, you have a choice. You can use threading, which is often simpler and works great. Folder code, or if you're dealing with a huge number of connections and need maximum efficiency, you go with the modern power of async IO. And in the end it all comes down to that one simple question. Is your programs bottleneck waiting for the world or is it thinking really hard? Once you know the answer, you'll know exactly which tool to reach for to unlock some serious performance in Python. So what's your next bottleneck going to be?