Examples of Ruby Multi-threading Examples

Introduction to Ruby Multi-threading

Multi-threading in Ruby allows you to run multiple threads of execution concurrently, making it a powerful tool for improving the performance of applications, especially when dealing with I/O operations or tasks that can be performed simultaneously. Below are three diverse examples of Ruby multi-threading that illustrate its practical applications.

Example 1: Concurrent HTTP Requests

In web applications, it’s common to make multiple HTTP requests to gather data from different APIs. By leveraging multi-threading, you can initiate these requests concurrently, greatly reducing the total waiting time.

require 'net/http'
require 'uri'

## List of API endpoints to fetch data from
urls = [
  'http://api.example.com/data1',
  'http://api.example.com/data2',
  'http://api.example.com/data3'
]

threads = []

urls.each do |url|
  threads << Thread.new do
    uri = URI.parse(url)
    response = Net::HTTP.get_response(uri)
    puts "Response from #{url}: #{response.code}"
  end
end

## Wait for all threads to complete
threads.each(&:join)

In this example, we create a separate thread for each URL in our list. Each thread performs an HTTP GET request and prints the response code. The use of Thread.new allows for concurrent execution, while threads.each(&:join) ensures that the main thread waits for all spawned threads to finish before exiting.

Notes

• This example uses a simple HTTP GET request. You may want to handle potential exceptions or errors for robustness.
• For further optimization, consider using a thread pool to limit the number of concurrent threads.

Example 2: Background Task Processing

Multi-threading can be beneficial for handling background tasks, such as processing data or performing calculations without blocking the main application flow. This is particularly useful in web applications where user experience is critical.

class DataProcessor
  def perform_calculation(data)
#    # Simulate a time-consuming calculation
    sleep 2
    puts "Processed data: #{data * 2}"
  end
end

processor = DataProcessor.new
threads = []

[1, 2, 3, 4, 5].each do |data|
  threads << Thread.new do
    processor.perform_calculation(data)
  end
end

threads.each(&:join)

In this example, we define a DataProcessor class with a method that simulates a time-consuming calculation. We then create a thread for each piece of data we want to process. Each thread runs the calculation concurrently, allowing multiple calculations to take place at once.

Notes

• This example uses sleep to simulate a long-running task. In a real-world scenario, replace this with actual processing logic.
• Consider using thread-safe data structures or mechanisms to avoid data races.

Example 3: File Downloading with Progress Tracking

When downloading multiple files, you can use multi-threading to improve the speed of the downloads while also providing feedback on progress. This example demonstrates how to implement basic progress tracking.

require 'open-uri'

files = [
  'http://example.com/file1.zip',
  'http://example.com/file2.zip',
  'http://example.com/file3.zip'
]

threads = []
progress = 0

files.each do |file|
  threads << Thread.new do
    puts "Starting download for #{file}..."
    open(file) do |u|
      File.open(File.basename(file), 'wb') do |f|
        f.write(u.read)
      end
    end
    progress += 1
    puts "Downloaded #{file} (#{progress}/#{files.size})"
  end
end

threads.each(&:join)
puts "All downloads completed!"

In this example, we download multiple files concurrently. Each thread handles the download of a single file, and we print progress updates as each download completes. This provides a visual indication of the status of the downloads.

Notes

• Ensure that you have permission to download the files specified in the URLs.
• For larger files, consider adding error handling and resuming downloads if interrupted.

By understanding and utilizing these examples of Ruby multi-threading, you can enhance the performance of your applications significantly. Experiment with these concepts to see how they can fit into your own projects.