Ruby Threads

Talk: https://www.youtube.com/watch?v=hiicldux-VE

Transcript

1. Ruby Thread Introduction to multithreaded programming with Ruby Luong Vo Luong Vo luong‑komorebi luong‑komorebi
2. Ruby ? 2 2
3. Thread ? 3 3
4. Thread == Thread of execution != Hardware thread Provides context for CPU Can be scheduled independently 4 4
5. A thread is a basic unit of CPU utilization, which comprises a thread ID, a program counter, a register set, and a stack. 5 5
6. Hardware vs Software thread A "hardware thread" is a physical CPU or core. 6 6
7. How many thread can a 4 core CPU run at once? 7 7
8. 4 core CPU can genuinely support 4 hardware threads at once ‑ the CPU really is doing 4 things at the same time 8 8
9. Then we are all limited to 4 threads ?? You are probably using Macbook with a Core i5‑8259U... 9 9
10. NO! 10 10
11. 1. Intel® Hyper‑Threading Technology 2. Hardware thread can run multiple software threads 3. Hardware thread ‑ OS / Software thread ‑ Language 11 11
12. 12 12
13. 13 13
14. Thread Scheduling Imagine reading a book, then take a break and comeback.... 14 14
15. Ruby 15 15
16. Thread in Ruby # Initialization thr = Thread.new { puts "Whats the big deal" } # status thr.status # => "sleep", "running", 'etc' # other operations thr.kill # should not be used ‑> raise exception thr.exit thr.stop && thr.wakeup thr.pass thr.join 16 16
17. Thread.main == Thread.current # Your Ruby programm is always running in a main thread. # When the main thread exits, all other threads are # immediately terminated and the process exits. 17 17
18. Maximum number of threads 10_000.times do |i| begin Thread.new { sleep } rescue ThreadError puts "Your thread limit is #{i} threads" Kernel.exit(true) end end # it depends, mine is: 4094 18 18
19. Thread provide contexts Threads share an address space: context, variable and AST (code tree). 19 19
20. Ruby maps its threads to OS native threads 100.times do Thread.new { sleep } end puts Process.pid # returns 26600 sleep # run in console: `top ‑l1 ‑pid 26600 ‑stats pid,th` 20 20
21. 21 21
22. Benefits of native threads Run on multiple processors Scheduled by the OS Blocking IO operations don't block other threads 22 22
23. Concurrency ? For free ? 23 23
24. Race condition 24 24
25. Race condition Occurs when two or more threads can access shared data and try to change it at the same time. Because the thread scheduling algorithm can swap between threads at any time, you don't know the order in which the threads will attempt to access the shared data. 25 25
26. Example: File Upload 26 26
27. files = { 'daddario.png' => '*image data*', 'elixir.png' => '*image data*' } expected_count = 2 100.times do uploader = FileUploader.new(files) uploader.upload actual_size = uploader.results.size if actual_size != expected_count raise("Race condition, size = #{actual_size}") end end puts 'No race condition this time' exit(0) 27 27
28. def results # Threads share AST, so here might be a # race condition (one thread creates Queue # then another one creates it again) # To fix: move assignment to #initialize @results ||= Queue.new end Threads share an address space: context, variable and AST (code tree). 28 28
29. Good practices 1. Avoid lazy instantiation in multi‑ thread environment 2. Avoid concurrent modifications 3. Protect concurrent modifications 29 29
30. Ruby Global Interpreter Lock 30 30
31. Common myth Ruby is incapable of using threads because of GIL 31 31
32. 32 32
33. 33 33
34. Facts 1. MRI allows concurrency but prevents parallelism 2. Every Ruby process and process fork has its own GIL 3. MRI releases GIL when thread hits blocking IO (HTTP request, console IO, etc.). Therefore, blocking IO could run in parallel 4. Other implementations (JRuby) don't have GIL 34 34
35. Reasons of GIL 1. Protect Ruby internal C code from race conditions (it is not always thread safe) 2. Protect calls to C extensions API 3. Protect developers from race conditions 35 35
36. CPU Bound vs IO Bound 36 36
37. IO bound tasks make sense to use threads 37 37
38. There always will be a sweet spot between utilization and context switching and it is important to find it 38 38
39. Computations‑ rich code on MRI runs better on 1 thread while on other implementations on N = CPU cores thread 39 39
40. 40 40
41. Thread Safety 41 41
42. Thread safe codes: 1. Doesn't corrupt your data 2. Leaves your data consistent 3. Leaves semantics of your program correct 42 42
43. Example: Order a product Order = Struct.new(:amount, :status) do def pending? status == 'pending' end def collect_payment puts "Collecting payment..." self.status = 'paid' end end order = Order.new(100.00, 'pending') 5.times.map do Thread.new do if order.pending? # check order.collect_payment # set end end end.each(&:join) 43 43
44. Mutex 44 44
45. Mutex Mutual exclusion, guarantees that no two threads enter the critical section of code at the same time Until the owning thread unlocks the mutex, no other thread can lock it The guarantee comes from the OS 45 45
46. Mutex tips Use mutex to read value. Remember: mutexes prevents parallel execution of critical sections. Make critical sections as small as possible. Deadlock may occur when one thread waiting for a mutex locked by another thread waiting itself for the first one. Use mutex#try_lock 46 46
47. 47 47
48. That's all. Thank you 48 48
49. Not yet, actually... 49 49
50. ALWAYS START WITH THE "WHY" 50 50
51. Why at the same time? Thread is just a terminology. The ultimate reason for its existence is our demand. 51 51
52. Why Concurrency? but not Parallelism 52 52
53. Why Threads? but not Processes? 53 53
54. Why concurrency with threads ? NODEJS ftw! 54 54
55. Beyond Ruby Threads 1. Popular application & ecosystem (Bundler, Puma, Phusion Passenger,...) 2. Concurrency Models (Actors, CSP, STM, Guilds,...) 3. Concurrency Patterns (ThreadPools, Reactor,...) 4. Other languages concurrency implementations (Golang, Erlang,...) 55 55
56. Think BIGGER! Code: Code: github.com/luong‑komorebi/intro‑to‑ruby‑threads/ github.com/luong‑komorebi/intro‑to‑ruby‑threads/ Slide: Slide: https://intro‑to‑ruby‑threads.luongvo.now.sh/ https://intro‑to‑ruby‑threads.luongvo.now.sh/ 56 56