Tackling Thread Safety in Python

Talk at Europython 2024 on Thread Safety : https://ep2024.europython.eu/session/tackling-thread-safety-in-python

Demo code available at: https://github.com/adarshdigievo/talks

1. Tackling Thread Safety in Python Europython 2024
2. Speakers Adarsh Divakaran Co-founder and Lead consultant Digievo Labs Jothir Adithyan Product Engineer Strollby, UST
3. Outline • Threading • Race Conditions • Thread Safety • Synchronization primitives • Making Programs thread safe
4. Threading Why use threading? • To improve application efficiency (concurrent execution, improve responsiveness) Sample - A banking app
5. Banking App - DB Init
6. Banking App - Initial Balance id name balance 1 John 100 2 Jane 100 3 Alice 100 Money in bank - 300
7. Banking App - Transfer Code
8. Banking App - Money Transfer (Single-Thread)
9. id name balance 1 John 90 2 Jane 100 3 Alice 110 Money in bank - 300 Banking App - Balance After Transfer
10. Banking App - Performance Issues Transfers get completed sequentially - slower
11. Banking App - Money Transfer (Multi-Thread)
12. Banking App - Balance After Transfer id name balance 1 John 90 2 Jane 90 3 Alice 110 Money in bank - 290
13. Banking App - Debugging the Issue Concurrent read & write happens due to threading This can lead to race conditions
14. Race Conditions Race conditions occur when we work with shared mutable data Non atomic operations can get context switched in between
15. Race Conditions - Context Switching
17. Race Conditions Consider two threads in our banking app. A user has an initial balance of 30. An amount of 100 is being transferred simultaneously to the user by each of the thread. 1. Thread 1 reads the current balance (30) 2. Thread 1 updates the current balance (130) 3. Before thread 1 saves to the database, thread 2 reads the value of A (gets 30) 4. Thread 2 updates balance as 130. 5. Thread 2 writes value of 130 to DB; thread 1 also does the same. The problem is that, a read is allowed midway of another modify operation.
18. Thread Safety A program is said to be thread-safe if it can be run using multiple threads without any unexpected side effects (like the one we seen in banking example)
19. When should we worry about Thread safety Is using threading as our concurrency framework Ref: Anthony Shaw - Unlocking the Parallel Universe: Subinterpreters and Free-Threading in Python 3.13 - Pycon US 2024
20. When should we worry about Thread safety Has shared mutable data & has non-atomic operations - Threads share memory location of parent process - No problem if no data is shared - No problem if code executed with threads is immutable and atomic
21. Non thread-safe examples - Print
22. Non thread safe examples - Print • Print function operation - prints the value, Then prints separator and end (by default \n) • It is thread unsafe because the operation is non atomic • Context switch can happen in between
23. Non thread safe examples - Print
24. Non thread safe examples - Singleton
25. Making programs thread safe • Don’t use threads (go with other concurrency frameworks) • Make operations atomic • Don’t share mutable data across threads • Use Synchronization primitives.
26. Synchronization Primitives • Lock • RLock • Semaphore • Event • Condition • Barrier
27. Synchronization Primitives - Lock A Lock is a synchronization primitive that allows only one thread to access a resource at a time. Practical Use-Case: Ensuring that only one thread can modify a shared variable at a time to prevent race conditions.
28. Synchronization Primitives - RLock An RLock is a reentrant lock that allows the same thread to acquire the lock multiple times without causing a deadlock. Practical Use-Case: Allowing a thread to re-enter a critical section of code that it already holds the lock for, such as in recursive functions.
29. Synchronization Primitives - Semaphore A Semaphore is a synchronization primitive that controls access to a resource by maintaining a counter, allowing a set number of threads to access the resource simultaneously. Practical Use-Case: Limiting the number of concurrent connections to a database to prevent overload. (eg: connection pooling)
30. Synchronisation Primitives - Event An Event is a synchronization primitive that allows one thread to signal one or more other threads that a particular condition has been met. Practical Use-Case: Notifying worker threads that new data is available for processing.
31. Synchronization Primitives - Condition A Condition is a synchronization primitive that allows threads to wait for certain conditions to be met before continuing execution. Practical Use-Case: Pausing a thread until a specific condition is met, such as waiting for a queue to be non-empty before consuming an item.
32. Synchronization Primitives - Barrier A Barrier is a synchronization primitive that allows multiple threads to wait until all threads have reached a certain point before any of them can proceed. Practical Use-Case: Ensuring that all worker threads complete their individual tasks before any thread proceeds to the next phase of a multi-phase computation.
33. Synchronisation Primitives - Lock
34. Synchronisation Primitives - Lock
35. Synchronisation Primitives - Deadlock
36. Synchronisation Primitives - Deadlock
37. Synchronisation Primitives - RLock
38. Synchronisation Primitives - RLock
39. Making Programs Thread Safe - Banking App
41. Making Programs Thread Safe - Banking App - The example here (using Python locks) is not suitable for production. - Multiple instances of our Python app can be deployed across regions. - Enable locks at the source of truth level. - Enable locks at the database level
42. Making Programs Thread Safe - Print
44. Making Programs Thread Safe - Singleton
45. Summary - Before moving to multithreading keep in mind that the code you are working with might not be designed for thread safety - even library code. - Before switching to multithreading, check for shared mutable data & atomicity requirements. - Add synchronization primitives to enforce thread-safety. “When in doubt, use a mutex!” - CPython docs ( https://docs.python.org/3/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe )
46. Thank You linkhq.co/adarsh linkhq.co/adithyan Get the talk slides & connect with us