Locked learning resources

Join us and get access to thousands of tutorials and a community of expert Pythonistas.

Unlock This Lesson

Locked learning resources

This lesson is for members only. Join us and get access to thousands of tutorials and a community of expert Pythonistas.

Unlock This Lesson

Python Thread Safety: Using a Lock and Other Techniques (Summary)

Christopher Trudeau
Thread Safety in Python: Locks and Other Techniques Christopher Trudeau 02:27
Recommended Tutorial Course Slides (.pdf) Sample Code (.zip) Ask a Question

You now know how to avoid race conditions in a multithreaded environment, and how to use the synchronization primitives provided by Python’s threading module. These tools are essential for ensuring that your code behaves correctly and predictably when multiple threads are involved, preventing issues that can arise from concurrent execution.

In this video course, you’ve learned how to:

  • Identify race conditions in code
  • Use Lock and RLock objects for mutual exclusion
  • Use Semaphore objects to limit concurrent access to resources
  • Leverage Event objects for simple signaling between threads
  • Use Condition objects to make threads conditionally wait
  • Use Barrier objects to coordinate thread execution

More Real Python resources to explore:

Download

Course Slides (.pdf)

 1.4 MB
Download

Sample Code (.zip)

 6.6 KB

00:00 In the previous lesson, I introduced you to barriers and briefly discussed when you should use synchronization primitives. In this lesson, I’ll summarize the course and point you at more resources.

00:11 Unless you’re explicitly coding it that way, Python code isn’t atomic. When you have multiple threads with shared resources between them, the operating systems swapping your threads out can have tricky implications on the determinism of your code.

00:24 You may have a race condition, meaning that your result will depend on the order the threads run their code. To deal with this problem, you should use synchronization primitives.

00:33 Python provides several. The Lock object can protect a block of code, ensuring that only one thread is in that block at a time. When your code uses .acquire() to get a lock, any other threads doing the same are made to wait until your thread releases the lock.

00:50 The RLock is a reentrant variation on the Lock, allowing a thread to acquire the lock multiple times without deadlocking. A Semaphore is a thread-safe counter typically used to limit the number of threads using a resource at any given time.

01:04 An Event is a Boolean switch that can be used to notify one or more threads of a change in state. A Condition combines the idea of an event and a lock, allowing you to lock for a resource, as well as wait until your thread is notified.

01:18 A Barrier combines a semaphore and a lock, acting as a stopping point until the given number of threads have arrived there.

01:27 If you ignored my advice in the intro of the course and just plowed ahead, well, good for you. Fight the man, even if that man is me. You may still find this general concurrency course helpful.

01:37 If you know threads but haven’t used asyncio or multi-processing, this might be a good next place for you. If you’re interested to learn more on the GIL, why it’s there, and what might happen if it goes away, this course can help you figure that out.

01:50 In fact, there’s a whole learning path on concurrency. Some of the courses and tutorials in it are the same ones I’ve mentioned, but there are others as well.

02:00 Finally, if you’re interested in lower-level mechanisms like threading, you might also be interested in the socket interface. You can use threads to handle multiple sockets at once, but there’s another way as well called a Selector. Like with threads, it does tricky operating system things to quickly switch between tasks, making it look like more than one thing is going on at a time.

02:22 I hope you found this course interesting. Thanks for your attention.

Become a Member to join the conversation.