What is a thread?

In computer science, a thread of execution is the smallest sequence of programmed instructions that can be managed independently by an operating system scheduler.

-- Wikipedia

Thread.main
Thread.current
Thread.new {}

What's in it for me?

Cheaper concurrency

• Cheaper in memory usage
• Less overhead than spawning a process

Code organization

• Handle signals (like ruby)
• Isolate task, functional units
• More...

Concurrency vs. Parallelism

Concurrency and parallelism are two related but distinct concepts.

Concurrency : Task A and task B both need to happen independently of each other. A starts running, and then B starts before A is finished, but they not necessarily going to be executed simultaniusly.

Parallelism : Task A and task B both running in the same time, simultaniusly.

Concurrent
       >---->    >---->>        Task A
>----->      >-->      >----->> Task B

Paralell
       >-------->>              Task A
>---------------------------->> Task B

Threading with different ruby implementations

Rubinius, JRuby and MacRuby...

...have real native OS threads and paralell execution.

MRI

• < 1.9 Green threads
• > 1.9 Native OS threads and fibers GIL/GVL

What is GIL a.k.a. GVL a.k.a. global lock?

• The GIL is a global lock around the execution of Ruby code.
• The biggest implication is that Ruby code will never run in parallel on MRI.

require 'digest/md5'

3.times.map do
  Thread.new do
    Digest::MD5.hexdigest(rand)
  end
end.each(&:value)

What's the reason for it?

What is possible with MRI?

require 'open-uri'

3.times.map do
  Thread.new do
    open('http://digitalnatives.hu')
  end
end.each(&:value)

How others solved this issue?

• Rubinius have fine-grained locks around the internal data structures, and helps gem (C extension) developers to avoid race conditions.

• JRuby, does not support C extensions, you can use java based extension instead.

Thread-safe code

@results ||= "some value"

Shorthand for

if @result.nil?
  temp = "some value"
  @result = temp
end

What happens if my code is not threadsafe?

• best case: nothing
• worst case:
  • corrupt data in memory/database
  • unpredictable results

How can I write threadsafe code?

• Avoid mutating globals (constants, the AST, class variables/methods)
• Create multiple objects instead a shared one
• Use Thread-locals
• Use resource pools
• Avoid lazy-loading
• Prefer data structures over mutexes
• Use immutable objects

Avoid or protect concurrent data modification

Mutexes

shared_mutex_accross_threads = Mutex.new
mutex.lock
mutex.unlock
mutex.synchronize {}

• Must be shared between the threads
• It has performance tradeoffs (mostly on Rubinius, JRuby)
• You should choose the place of lock carefully
• You should lock the smallest possible part of the code
• Avoid deadlocks

ConditionVariable

These can be used to communicate between threads to synchronize resource access.

• Thread A produces items into an array
• Thread B waits for the items (conditional variable)
• When Th. A signals through the cond. var.
• Th. B can access the new item from the array

require 'thread'

array = []
mutex = Mutex.new
cond_var = ConditionVariable.new

Thread.new do
  10.times do
    mutex.synchronize do
      sleep(rand)
      array << rand
      cond_var.signal
    end
  end
end
Thread.new do
  10.times do
    mutex.synchronize do
      cond_var.wait(mutex) while array.empty?
      puts "Processing #{array.shift}"
    end
  end
end

Queue

The only thread-safe data structure from standard lib. Can be implemented with an Array, a Mutex and a ConditionVariable.

• #push and #pop
• blocks on #pop

How many threads do I need?

CPU-bound vs IO-bound