Ruby Multithreading

Each program running on the system is a process. Each process contains one or more threads.

A thread is a single sequential control flow in a program. Running multiple threads simultaneously in a single program to complete different tasks is called multi-threading.

In Ruby, we can create multi-threading through the Thread class. Ruby's threads are lightweight and can be used to implement parallel code efficiently.

Create Ruby thread

To start a new thread, simply call Thread.new:

# Thread #1　Code section
Thread.new {
　　# Thread #2　Execute code
}
# Thread #1　Execute code

Online Example

The following example demonstrates how to use multi-threading in a Ruby program:

Online Example

#!/usr/bin/ruby
　
def func1
　　　i=0
　　　while i<=2
　　　　　　puts "func1　at: #{Time.now}"
　　　　　　sleep(2)
　　　　　　i=i+1
　　　end
end
　
def func2
　　　j=0
　　　while j<=2
　　　　　　puts "func2　at: #{Time.now}"
　　　　　　sleep(1)
　　　　　　j=j+1
　　　end
end
　
puts "Started At #{Time.now}"
t1=Thread.new{func1()
t2=Thread.new{func2()
t1.join
t2.join
puts "End at #{Time.now}"

The execution result of the above code is:

Started At Wed May　14　08:21:54　-0700　2014
func1　at: Wed May　14　08:21:54　-0700　2014
func2　at: Wed May　14　08:21:54　-0700　2014
func2　at: Wed May　14　08:21:55　-0700　2014
func1　at: Wed May　14　08:21:56　-0700　2014
func2　at: Wed May　14　08:21:56　-0700　2014
func1　at: Wed May　14　08:21:58　-0700　2014
End at Wed May　14　08:22:00　-0700　2014

Thread Life Cycle

1The creation of a thread can use Thread.new, and it can also use Thread.start or Thread.fork to create a thread with the same syntax.

2After creating a thread, there is no need to start it, the thread will execute automatically.

3The Thread class defines some methods to control threads. The thread executes the code block in Thread.new.

4The last statement in the thread code block is the value of the thread, which can be called through the thread's methods. If the thread has completed execution, then the thread value is returned, otherwise no value is returned until the thread is completed.

5By using the Thread.current method, it returns an object representing the current thread. The Thread.main method returns the main thread.

6By using the Thread.Join method to execute the thread, this method will suspend the main thread until the current thread is completed.

thread status

There are5There are

Thread and Exception

When a thread occurs an exception and is not caught by rescue, the thread is usually terminated without warning. However, if other threads are waiting for this thread due to Thread#join, then the waiting threads will also be triggered by the same exception.

begin
　　t = Thread.new do
　　　　Thread.pass  # The main thread is indeed waiting for join
　　　　raise "unhandled exception"
　　end
　　t.join
rescue
　　p $!  # => "unhandled exception"
end

Use the following3This method can cause the interpreter to interrupt its execution when a thread terminates due to an exception.

• Specify when starting the script.-dOption, and run in debug mode.

• Using Thread.abort_on_exception to set the flag.

• Use Thread#abort_on_exception to set the flag for the specified thread.

When using the above3After using this method, the entire interpreter will be interrupted.

t = Thread.new { ... }
t.abort_on_exception = true

Thread Synchronization Control

In Ruby, there are three ways to implement synchronization, namely:

1Through the Mutex class to implement thread synchronization

2. The Queue class that regulates data transfer implements thread synchronization

3. Use ConditionVariable to implement synchronization control

Thread synchronization is implemented through the Mutex class

Thread synchronization control is implemented through the Mutex class. If a program variable is needed simultaneously by multiple threads, part of this variable can be locked using lock. The code is as follows:

Online Example

#!/usr/bin/ruby
　
require "thread"
puts "Synchronize Thread"
　
@num=200
@mutex=Mutex.new
　
def buyTicket(num)
　　　　　@mutex.lock
　　　　　　　　　　if @num>=num
　　　　　　　　　　　　　　　@num=@num-num
　　　　　　　　　　　　　　　puts "You have successfully bought #{num} tickets"
　　　　　　　　　　else
　　　　　　　　　　　　　　　puts "Sorry, not enough tickets"
　　　　　　　　　　end
　　　　　@mutex.unlock
end
　
ticket1=Thread.new　10　do
　　　　　10.times do |value|
　　　　　ticketNum =15
　　　　　buyTicket(ticketNum)
　　　　　sleep 0.01
　　　　　end
end
　
ticket2=Thread.new　10　do
　　　　　10.times do |value|
　　　　　ticketNum =20
　　　　　buyTicket(ticketNum)
　　　　　sleep 0.01
　　　　　end
end
　
sleep　1
ticket1.join
ticket2.join

The execution result of the above code is:

Synchronize Thread
you have successfully bought　15　tickets
you have successfully bought　20 tickets
you have successfully bought　15　tickets
you have successfully bought　20 tickets
you have successfully bought　15　tickets
you have successfully bought　20 tickets
you have successfully bought　15　tickets
you have successfully bought　20 tickets
you have successfully bought　15　tickets
you have successfully bought　20 tickets
you have successfully bought　15　tickets
Sorry, not enough tickets
Sorry, not enough tickets
Sorry, not enough tickets
Sorry, not enough tickets
Sorry, not enough tickets
Sorry, not enough tickets
Sorry, not enough tickets
Sorry, not enough tickets
Sorry, not enough tickets

In addition to using lock to lock variables, try_lock can also be used to lock variables, and Mutex.synchronize can be used to synchronize access to a variable.

The Queue class that regulates data transfer implements thread synchronization

The Queue class represents a thread-safe queue that can synchronize access to the end of the queue. Different threads can use the same instance of the class, but there is no need to worry about the synchronization of the data in the queue. Additionally, using the SizedQueue class can limit the length of the queue.

The SizedQueue class can greatly facilitate the development of thread-synchronized applications, as it is not necessary to worry about thread synchronization as long as items are added to this queue.

The classic producer-consumer problem:

Online Example

#!/usr/bin/ruby
　
require "thread"
puts "SizedQueue Test"
　
queue = Queue.new
　
producer = Thread.new do
　　　　　10.times do |i|
　　　　　　　　　　sleep rand(i) # Let the thread sleep for a while
　　　　　　　　　　queue << i
　　　　　　　　　　puts "#{i} produced"
　　　　　end
end
　
consumer = Thread.new do
　　　　　10.times do |i|
　　　　　　　　　　value = queue.pop
　　　　　　　　　　sleep rand(i/2)
　　　　　　　　　　puts "consumed #{value}"
　　　　　end
end
　
consumer.join

Program output:

SizedQuee Test
0 produced
1　produced
consumed 0
2　produced
consumed　1
consumed　2
3　produced
consumed　34　produced
consumed　4
5　produced
consumed　5
6　produced
consumed　6
7　produced
consumed　7
8　produced
9　produced
consumed　8
consumed　9

Thread Variables

Threads can have their private variables, which are written to the thread when the thread is created. They can be used within the scope of the thread but cannot be shared outside the thread.

But what if the local variables of a thread need to be accessed by other threads or the main thread? Ruby provides a way to create thread variables by name, similar to treating threads as hash-style hash tables. Data can be written using []= and read using [].

Online Example

#!/usr/bin/ruby
　
count = 0
arr = []
　
10.times do |i|
　　　arr[i] = Thread.new {
　　　　　　sleep(rand(0)/10.0)
　　　　　　Thread.current["mycount"] = count
　　　　　　count　+=　1
　　　}
end
　
arr.each {|t| t.join; print t["mycount"], ", " }
puts "count = #{count}"

The output result of the above code is:

8, 0,　3,　7,　2,　1,　6,　5,　4,　9, count =　10

The main thread waits for the subthread to complete and then outputs each value separately. .

Thread Priority

The priority of a thread is a major factor affecting thread scheduling. Other factors include the length of time a thread occupies the CPU, thread grouping scheduling, etc.

You can get the priority of a thread using the Thread.priority method and adjust the priority using Thread.priority=.

The default priority of a thread is 0. Threads with higher priority should execute faster.

A thread can access all the data within its scope, but what should you do if you need to access data from another thread within a certain thread? The Thread class provides methods for threads to access each other's data, and you can simply treat a thread as a hash table, where you can write data using []= within any thread and read data using [].

athr = Thread.new { Thread.current["name"] = "Thread A"; Thread.stop }
bthr = Thread.new { Thread.current["name"] = "Thread B"; Thread.stop }
cthr = Thread.new { Thread.current["name"] = "Thread C"; Thread.stop }
Thread.list.each {|x| puts "#{x.inspect}: #{x["name"]}"}

As can be seen, by treating threads as a hash table and using the [] and []= methods, we have achieved data sharing between threads.

Thread mutual exclusion

Mutex (Mutual Exclusion = mutual exclusion lock) is a mechanism used in multithreaded programming to prevent two threads from reading and writing the same public resource (such as global variables) at the same time.

An example of not using mutex

Online Example

#!/usr/bin/ruby
require 'thread'
　
count1　=2　=
difference = 0
counter = Thread.new do
　　　loop do
　　　　　　count1　+=　1
　　　　　　count2　+=　1
　　　end
end
spy = Thread.new do
　　　loop do
　　　　　　difference　+= (count1　-　count2).abs
　　　end
end
sleep　1
puts "count"1　: #{count1"
puts "count"2　: #{count2"
puts "difference : #{difference}"

The following is the output result of the example run:

count1　:　　9712487
count2　:　　12501239
difference : 0

An example of using mutex

Online Example

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new
　
count1　=2　=
difference = 0
counter = Thread.new do
　　　loop do
　　　　　　mutex.synchronize do
　　　　　　　　　count1　+=　1
　　　　　　　　　count2　+=　1
　　　　　　end
　　　　end
end
spy = Thread.new do
　　　loop do
　　　　　　　mutex.synchronize do
　　　　　　　　　　difference　+= (count1　-　count2).abs
　　　　　　　end
　　　end
end
sleep　1
mutex.lock
puts "count"1　: #{count1"
puts "count"2　: #{count2"
puts "difference : #{difference}"

The following is the output result of the example run:

count1　:　　1336406
count2　:　　1336406
difference : 0

Deadlock

Two or more computational units are waiting for each other to stop running to obtain system resources, but no one exits in advance, this situation is called deadlock.

For example, a process p1Occupied the display and must also use the printer, while the printer is occupied by process p2Occupation, p2And it must use the display, thus forming a deadlock.

When using Mutex objects, we need to be aware of thread deadlock.

Online Example

#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new
　
cv = ConditionVariable.new
a = Thread.new {
　　　mutex.synchronize {
　　　　　　puts "A: I have critical section, but will wait for cv"
　　　　　　cv.wait(mutex)
　　　　　　puts "A: I have critical section again! I rule!"
　　　}
}
　
puts "(Later, back at the ranch...)"
　
b = Thread.new {
　　　mutex.synchronize {
　　　　　　puts "B: Now I am critical, but am done with cv"
　　　　　　cv.signal
　　　　　　puts "B: I am still critical, finishing up"
　　　}
}
a.join
b.join

The output result of the above example is as follows:

A: I have critical section, but will wait for cv
(Later, back at the ranch...)
B: Now I am critical, but am done with cv
B: I am still critical, finishing up
A: I have critical section again! I rule!

Thread class methods

The complete Thread (thread) class methods are as follows:

Thread Example Method

The following example calls the thread example method join:

Online Example

#!/usr/bin/ruby
　
thr　=　Thread.new　do　　　#　Example
　　　puts　"In　second　thread"
　　　raise　"Raise　exception"
end
thr.join　　　#　Call the example method　join

The following is a complete list of example methods: