Concurrency in Python

MULTITHREADING &  
MULTIPROCESSING IN PYTHON
MOSKY
2

MOSKY
PYTHON CHARMER @ PINKOI
 
MOSKY.TW
3

OUTLINE
• Introduction
• Producer-Consumer Pattern
4

OUTLINE
• Introduction
• Python’s Flavor
4

OUTLINE
• Introduction
• Python’s Flavor
• Misc. Techiques
4

MULTITHREADING
• GIL
• Only one thread runs at any given time.
6

MULTITHREADING
• GIL
• Only one thread runs at any given time.
• It still can improves IO-bound problems.
6

MULTIPROCESSING
• It uses fork.
7

MULTIPROCESSING
• It uses fork.
• Processes can run at the same time.
7

MULTIPROCESSING
• It uses fork.
• Use more memory.
7

MULTIPROCESSING
• It uses fork.
• Use more memory.
• Note the initial cost.
7

IS IT HARD?
• Avoid shared resources.
8

IS IT HARD?
• e.g., vars or shared memory, ﬁles, connections, …
8

IS IT HARD?
• Understand Python’s ﬂavor.
8

IS IT HARD?
• Understand Python’s ﬂavor.
• Then it will be easy.
8

SHARED RESOURCE
• Race condition: 
T1: RW 
T2: RW 
T1+T2: RRWW
9

SHARED RESOURCE
T1: RW 
T2: RW 
T1+T2: RRWW
• Use lock → Thread-safe: 
T1+T2: (RW) (RW)
9

SHARED RESOURCE
T1: RW 
T2: RW 
T1+T2: RRWW
T1+T2: (RW) (RW)
• But lock causes worse performance and deadlock.
9

SHARED RESOURCE
T1: RW 
T2: RW 
T1+T2: RRWW
T1+T2: (RW) (RW)
• But lock causes worse performance and deadlock.
• Which is the hard part.
9

DIAGNOSE PROBLEM
• Where is the bottleneck?
10

DIAGNOSE PROBLEM
• Where is the bottleneck?
• Divide your problem.
10

PRODUCER-CONSUMER
PATTERN
• A queue
12

PRODUCER-CONSUMER
PATTERN
• A queue
• Producers → A queue
12

PRODUCER-CONSUMER
PATTERN
• A queue
• A queue → Consumers
12

PRODUCER-CONSUMER
PATTERN
• A queue
• A queue → Consumers
• Python has built-in Queue module for it.
12

EXAMPLES
• https://docs.python.org/2/library/
queue.html#queue-objects
• https://github.com/moskytw/mrbus/blob/master/
mrbus/base/pool.py
13

WHY .TASK_DONE?
• It’s for .join.
14

WHY .TASK_DONE?
• When the counter goes zero,  
it will notify the threads which are waiting.
14

WHY .TASK_DONE?
• When the counter goes zero,  
it will notify the threads which are waiting.
• It’s implemented by threading.Condition.
14

15
• Lock — primitive lock: .acquire / .release
THE THREADING MODULE

15
• RLock — owner can reenter

15
• RLock — owner can reenter
• Semaphore — lock when counter goes zero

• Condition —  
.wait for .notify / .notify_all
16

• Event — .wait for .set; simplifed Condition
16

• Event — .wait for .set; simplifed Condition
• with lock: …
16

THE MULTIPROCESSING MODULE
• .Process
17

• .Process
• .JoinableQueue
17

• .Process
• .JoinableQueue
• .Pool
17

• .Process
• .JoinableQueue
• .Pool
• …
17

19
• It’s not that “daemon”.
DAEMONIC THREAD

19
• Just will be killed when Python shutting down.
DAEMONIC THREAD

19
• Immediately.
DAEMONIC THREAD

19
• Immediately.
• Others keep running until return.
DAEMONIC THREAD

SO, HOW TO STOP?
• Set demon and let Python clean it up.
20

SO, HOW TO STOP?
• Set demon and let Python clean it up.
• Let it return.
20

BUT, THE THREAD IS BLOCKING
21

BUT, THE THREAD IS BLOCKING
• Set timeout.
21

HOW ABOUT CTRL+C?
• Only main thread can receive that.
22

HOW ABOUT CTRL+C?
• Only main thread can receive that.
• BSD-style.
22

BROADCAST SIGNAL  
TO SUB-THREAD
23

TO SUB-THREAD
• Set a global ﬂag when get signal.
23

TO SUB-THREAD
• Let thread read it before each task.
23

TO SUB-THREAD
• No, you can’t kill non-daemonic thread.
23

TO SUB-THREAD
• Just can’t do so.
23

TO SUB-THREAD
• Just can’t do so.
• It’s Python.
23

TO SUB-PROCESS
24

TO SUB-PROCESS
• Just broadcast the signal to sub-processes.
24

TO SUB-PROCESS
• Just broadcast the signal to sub-processes.
• Start with register signal handler: 
signal(SIGINT, _handle_to_term_signal)
24

• Realize process context if need: 
pid = getpid() 
pgid = getpgid(0) 
proc_is_parent = (pid == pgid)
25

pid = getpid() 
• Off the handler: 
signal(signum, SIG_IGN)
25

pid = getpid() 
• Off the handler: 
signal(signum, SIG_IGN)
• Broadcast: 
killpg(pgid, signum)
25

JUST THREAD IT OUT
• Or process it out.
27

JUST THREAD IT OUT
• Let main thread exit earlier. (Looks faster!)
27

JUST THREAD IT OUT
• Let main thread keep dispatching tasks.
27

JUST THREAD IT OUT
• “Async”
27

JUST THREAD IT OUT
• “Async”
• And ﬁx some stupid behavior. 
(I meant atexit with multiprocessing.Pool.)
27

COLLECT RESULT SMARTER
• Put into a safe queue.
28

• Use a thread per instance.
28

• Use a thread per instance.
• Learn “let it go”.
28

EXAMPLES
mrbus/base/pool.py#L45
mrbus/model/core.py#L30
29

MONITOR THEM
• No one is a master at ﬁrst.
30

MONITOR THEM
• Don’t guess.
30

MONITOR THEM
• Don’t guess.
• Just use a function to print log.
30

BENCHMARK THEM
31

BENCHMARK THEM
• Don’t guess.
31

BENCHMARK THEM
• Don’t guess.
• Just prove it.
31

CONCLUSION
• Avoid shared resource  
— or just use producer-consumer pattern.
32

CONCLUSION
• Signals only go main thread.
32

CONCLUSION
• Just thread it out.
32

CONCLUSION
• Collect your result smarter.
32

CONCLUSION
• Collect your result smarter.
• Monitor and benchmark your code.
32

Concurrency in Python

More Related Content

What's hot

Viewers also liked

Similar to Concurrency in Python

More from Mosky Liu

Recently uploaded

Concurrency in Python