How to Use Ruby Threads?

What are Ruby Threads?

Ruby Threads are an essential feature of the Ruby programming language. These threads act as lightweight sub-processes that can run simultaneously alongside other threads within a single program. The main purpose of using threads in Ruby is to achieve parallel execution of tasks, which leads to enhanced performance and responsiveness of the application. Managed by the Ruby interpreter, these threads are scheduled for execution by the underlying operating system, allowing for efficient utilization of system resources.

Developers can use Ruby threads to build applications that can handle multiple tasks simultaneously. This is particularly advantageous for tasks that require significant computational power, involve I/O operations, or benefit from concurrent execution for improved performance. Ruby threads provide a higher-level abstraction, making it easier to implement concurrent behaviour and simplifying the development of multi-threaded programs.

Creating Ruby Threads

Syntax:

The code within the block will be executed in the new thread simultaneously. We can do any operations or computations that we want to run simultaneously within the block.

Example:

Output:

In the above example, we create two threads, thread1 and thread2, that each print a different message. The join method is used to ensure that the main thread waits for the completion of both child threads before exiting.

It is important to note here that the print message of thread2 may also get executed before that of thread1. It is because of the scheduling of the operating system that any thread can be executed first. So order of output can be different based on the execution of threads.

Terminating Ruby Threads

Threads in Ruby are terminated automatically when the code within the thread block completes. However, there might be cases where you need to explicitly terminate a thread. The Thread#kill method can be used to forcefully terminate a thread.

Here's an example:

It's important to note that forcefully terminating a thread can lead to unpredictable behaviour and potential resource leaks. It is generally recommended to let threads terminate naturally by allowing the code within the thread block to complete.

Threads and Exceptions

When an exception occurs within a thread, it can be caught and handled in the same way that it would in a conventional Ruby program. Unhandled exceptions in a thread, on the other hand, do not propagate to the main thread by default. Before starting the thread, we can set the Thread.abort_on_exception property to true to ensure that exceptions are propagated.

Here's an illustration:

The Thread.abort_on_exception property is set to true in the above example, causing the main thread to raise an exception when the child thread encounters an unhandled exception. After that, the exception is captured and handled in the main thread.

Thread Pools

Thread Pool is an abstraction that allows us to assign a task to a pool of threads, where one of the available threads will execute the task. Thread pools are beneficial in scenarios where the overhead of creating and destroying threads is a concern. By creating a pool of reusable worker threads and reusing them for different tasks, the performance of long-running applications, such as services, can be significantly improved.

The concurrent-ruby gem provides higher-level abstractions in addition to thread pools. Thread pools are referred to as 'executors'. An executor is an object that can accept a unit of work and execute it. Thread pools are the primary type of executor we will encounter, with other types primarily used for testing or unusual edge cases.

Here is an example of using a thread pool executor:

We start a thread pool with 5 threads in this example. The post function is then used to submit tasks to the thread pool. Each task in the pool prints the thread id responsible for executing it.

Thread Variables

Ruby threads have thread-local variables that can be used to store and access data specific to each thread. Thread-local variables are isolated and not shared among threads. To define and access thread-local variables, we can use the Thread.current object.

Here's an example:

In the above example, we define a thread-local variable greet using the Thread.current object and assign it the value Hello. We then access this variable and print the value within the thread.

Thread Priorities

Ruby threads have a concept of priority that can be used to influence their scheduling. The default thread priority is 0. Higher-priority threads are given preference by the Ruby interpreter during scheduling. To set the priority of a thread, we can use the Thread#priority= method.

Here's an example:

In the above example, we define a thread and then change the priority of that thread.

Thread Exclusion

In multi-threaded programming, concurrent access and modification of shared resources by multiple threads can create race conditions and data corruption. These issues arise when two or more threads try to access the same resource simultaneously, resulting in unpredictable and incorrect outcomes.

To tackle the issue of multiple threads accessing shared resources simultaneously, the concept of mutual exclusion comes into play. It guarantees that only one thread can access a shared resource at any given time, thereby avoiding conflicts and upholding data integrity. To achieve mutual exclusion, a synchronization mechanism known as a Mutex is commonly employed.

Mutex (short for mutual exclusion) is a mechanism that prevents several threads from accessing shared resources at the same time. A Mutex assures that only one thread at a time may obtain a lock, preventing race situations and data corruption. To use a Mutex, we can create an instance of the Mutex class and synchronize access to shared resources using the Mutex#synchronize method.

Here's an illustration:

In the above example, we create a mutex using the Mutex.new method. We then synchronize access to critical sections of code using the Mutex#synchronize method, ensuring that only one thread can execute the protected block at a time.

Handling Deadlock

Deadlock is a situation where two or more threads are blocked indefinitely, waiting for each other to release resources. Deadlocks can occur when threads acquire locks in different orders, leading to a circular dependency. To avoid deadlocks, it's essential to carefully design our multithreaded code and ensure that locks are acquired in a consistent order.

Here are some general guidelines to prevent deadlocks:

• Always acquire locks in the same order across all threads.
• Use timeouts when acquiring locks to prevent indefinite waiting.
• Use thread-safe data structures and libraries to minimize the need for manual synchronization

Thread States

Ruby threads can be in various states during their execution.

Some common thread states include:

• Running: This refers to the thread that is currently executing or is ready to execute as soon as CPU resources become available.
• Sleeping: This represents a thread that is currently in a sleep state, waiting for IO operations to complete, or has voluntarily paused its execution.
• Aborted: This is an intermediate state for a thread that has been forcefully terminated but has not yet fully completed its termination process.
• Terminated with Exception: This refers to a thread that has encountered an exception during its execution and has subsequently terminated.
• Terminated Normally: This denotes a thread that has completed its execution without any exceptions or issues and has terminated normally.

Understanding thread states can help us debug and troubleshoot issues related to thread synchronization and concurrency.

Thread Class Methods

In Ruby, the Thread class provides various useful class methods for managing and manipulating threads.

Some examples of commonly utilized class methods are:

• Thread.list: Returns an array of all currently running threads.
• Thread.current: Returns the currently executing thread.
• Thread.abort_on_exception: Returns or sets whether unhandled exceptions in threads should raise an exception in the main thread.

These class methods can be handy when you need to retrieve information about running threads or control certain aspects of thread behaviour.

Thread Instance Methods

The Thread class also includes several instance methods that allow us to interact with threads while they are running.

Some examples of regularly used instance methods are:

• Thread#join: This method waits for the thread to finish.
• Thread#kill: Kills the thread.
• Thread#priority=: Determines the thread's priority.
• Thread#status: Returns the current state of the thread.
• Thread#value: This method waits for the thread to complete before returning its value.

These instance methods allow us to manage thread execution and get information and results from threads.