Ruby supports concurrency through threads but not true parallelism due to the Global Interpreter Lock (GIL). The GIL prevents more than one thread of Ruby code from running simultaneously. While threads cannot run in parallel, I/O-bound operations allow other threads to run by releasing the GIL. Newer implementations like JRuby and Rubinius as well as potential future changes to Ruby aim to improve support for true parallelism.

1. Concurrency in Ruby
Aleš Kotnik

2. source: Wikipedia
Source: Wikipedia

3. Every two years we will
● halve the size of transistors
● double the number of transistors per chip
● double the clock frequency

4. Transistors
are still
getting
smaller
source: http://cpudb.stanford.edu/

5. But clock
frequency is
not raising
any more
source: http://cpudb.stanford.edu/

6. CPU caches
help
source: http://cpudb.stanford.edu/
The speed of the RAM chips and
of the communication bus are
two other bottlenecks

7. How to speed up
programs?
● run them on many (logical) cores in parallel
with OS threads
● not an easy task to do
● you have to get the concurrency right first

8. Rob Pike's talk
from 2013
"If you looked at the
programming languages of
today you probably get this
idea that the world is
object-oriented. But it's not. It's
actually parallel."
http://bit.ly/pike2013

9. Concurrency is not
Parallelism
concurrency dealing with many things at the
same time
(it's about structure/design)
parallelism doing many things at the same time

10. But Ruby can't do
parallelism, right?
● MRI (Matz's C ruby)
● Jruby
● Rubinius

11. Benchmarks require 'benchmark'
n = 30_000_000
Benchmark.bm do |x|
t1 = Thread.new { x.report {for i in 1..n; a = "1"; end } }
t2 = Thread.new { x.report {n.times do ; a = "1"; end } }
t3 = Thread.new { x.report {1.upto(n) do ; a = "1"; end } }
t1.join # wait for thread 1 to finish
t2.join # wait for thread 2 to finish
t3.join # wait for thread 3 to finish
end

12. ruby
user system total real
6.420000 0.040000 6.460000 ( 6.816842)
6.440000 0.040000 6.480000 ( 6.837540)
6.250000 0.040000 6.290000 ( 6.577156)
jruby
user system total real
8.810000 0.150000 8.960000 ( 3.284740)
9.550000 0.160000 9.710000 ( 3.622296)
10.320000 0.180000 10.500000 ( 4.413089)

13. GIL
Global Interpreter Lock
Prevents more than one thread of ruby code to
run in parallel.
Protects internal consistency of the ruby's VM
state
It's not documented, not covered by public tests.

14. Another
interesting
benchmark
Let's download from
multiple URLS

15. MRI rocks
MRI performs great!
How is that?
I/O is blocking - GIL is
released.

16. Push to array
from multiple
threads

17. Push to array from
multiple threads
ruby: 5000
jruby: 4284
rubinius: 3231

18. array#push method is run by
array#<< is defined as: rb_ary_push
VALUE
rb_ary_push(VALUE ary, VALUE item)
{
long idx = RARRAY_LEN(ary);
VALUE target_ary = ary_ensure_room_for_push(ary, 1);
RARRAY_PTR_USE(ary, ptr, {
RB_OBJ_WRITE(target_ary, &ptr[idx], item);
});
ARY_SET_LEN(ary, idx + 1);
return ary;
}

19. So my code is thread-safe as long
as it is run on MRI, right?
Let's check

20. Let's put some threads to work

21. The sheep might get shorn multiple times in a row
> ruby sheep.rb
shearing...
shearing...
> jruby sheep.rb
shearing...
> xruby sheep.rb
shearing...
shearing...

22. Strategies to handle concurrency
● thread scheduler could interrupt the thread at any moment
● resources (memory, files, ...) may be shared among multiple threads
● we need atomic operations

23. The usual suspects
for synchronise resource sharing
● locks (inside process)
● mutex (between processes)
● semaphore (mutex for multiple number of threads)

24. Cons of
locks/mutex/semaphore
complex (deadlocks,
starvation, livelocks)
leaky (no abstractions)
no composability (Account
transfer)

25. Example: The transfer between two accounts
Simon Peyton Jones (suggests STM) Not always 1.000.000
Money can disappear in the
thin air (the same substance it
is usually created from).

26. Alternatives?
● Actor model (Erlang, Scala)
● CSP (Go, Ruby, Clojure, Kotlin)
● Software Transactional Memory (Haskell, Clojure, Ruby)
● Guilds (New Ruby Concurrency model for Ruby 3
proposed by Koichi Sasada)

27. Source: Wikipedia

28. Workers

29. Workers

30. Don't communicate by sharing.
Share by communicating.

31. What would you change
in Ruby if you could go
back in time?
"I would remove the thread and add actors or
some other more advanced concurrency
features"
Yukihiro "Matz" Matsumoto
Source: Wikipedia

32. The Take-away
get familiar with the alternative
concurrency handling strategies,
read Tony Hoare's CSP original paper,
forget everything from this talk and keep
writing the single threaded Ruby code
that mostly does I/O.