Ruby 提供了多线程支持，可以利用多核处理器来并发执行任务。多线程编程是提高程序效率和响应速度的重要手段，尤其是在需要处理大量计算或 I/O 操作的情况下。Ruby 的线程功能通过标准库中的 Thread 类提供，可以用来执行并行任务。

📌 目录

  1. 🔹 什么是多线程？
  2. 🔹 Ruby 中的线程
  3. 🔹 创建和启动线程
  4. 🔹 线程同步
  5. 🔹 使用线程池
  6. 🔹 示例代码：多线程应用
  7. 🔹 常见问题
  8. 🔹 参考资料

🔹 什么是多线程？

多线程是指在同一进程中同时执行多个线程，每个线程代表一个独立的执行流。多线程允许程序在执行时处理多个任务，而不会因为某一任务的阻塞而停止其他任务。

在多核处理器上，多个线程可以并行执行，最大化硬件资源的利用率。常见的多线程应用场景包括：

  • 高并发的网络请求处理。
  • 数据库操作。
  • 大量独立计算的并行执行。

🔹 Ruby 中的线程

Ruby 在其标准库中提供了线程支持，可以通过 Thread 类来创建和管理线程。Ruby 的多线程实现通常基于操作系统级线程，并且使用了全局解释器锁（GIL）。这意味着在 MRI（Matz’s Ruby Interpreter）实现中，虽然支持多线程，但在同一时间内只有一个线程可以执行 Ruby 代码，其他线程会等待 GIL。

线程的创建和管理

Ruby 提供了 Thread 类，可以用来创建和管理线程。一个线程是一个独立的执行流，可以并行运行。

# 创建一个线程并启动
thread = Thread.new do
  puts "This is a new thread!"
end

# 主线程等待子线程完成
thread.join
puts "Main thread finished"
  • Thread.new：创建一个新线程并启动。
  • join：让主线程等待子线程执行完成。

🔹 创建和启动线程

1. 启动多个线程

threads = []

# 创建 5 个线程
5.times do |i|
  threads << Thread.new(i) do |n|
    sleep 1
    puts "Thread #{n} finished"
  end
end

# 等待所有线程完成
threads.each(&:join)

puts "All threads finished"

在这个例子中：

  • 我们启动了 5 个线程，每个线程会睡眠 1 秒钟。
  • 使用 join 等待所有线程完成。

2. 线程间共享数据

多个线程可以访问和修改共享数据。为了避免并发问题，必须确保线程安全。常见的做法是使用锁（mutex）来同步访问共享数据。

require 'thread'

counter = 0
mutex = Mutex.new

threads = []

# 创建 10 个线程，修改共享数据
10.times do
  threads << Thread.new do
    mutex.synchronize do
      counter += 1
    end
  end
end

# 等待所有线程完成
threads.each(&:join)

puts "Counter value: #{counter}"

在这个例子中：

  • mutex.synchronize 用于确保同一时间只有一个线程可以访问和修改 counter。

🔹 线程同步

线程同步是保证多个线程同时访问共享资源时不会导致数据竞争或不一致问题。常见的同步机制包括：

  1. Mutex（互斥锁）：确保同一时刻只有一个线程可以访问共享资源。
  2. Condition Variable（条件变量）：用于线程之间的通信和同步。

1. 使用 Mutex 进行线程同步

require 'thread'

counter = 0
mutex = Mutex.new

threads = []

5.times do
  threads << Thread.new do
    mutex.synchronize do
      counter += 1
      puts "Counter: #{counter}"
    end
  end
end

threads.each(&:join)

在这个例子中，mutex.synchronize 确保了每次只有一个线程可以进入临界区并修改 counter 变量。

2. 使用 ConditionVariable 进行线程通信

require 'thread'

mutex = Mutex.new
condition = ConditionVariable.new
flag = false

threads = []

# 创建生产者线程
threads << Thread.new do
  mutex.synchronize do
    sleep 1
    flag = true
    condition.signal  # 通知消费者线程
    puts "Producer: Flag set to true"
  end
end

# 创建消费者线程
threads << Thread.new do
  mutex.synchronize do
    condition.wait(mutex) until flag  # 等待 flag 为 true
    puts "Consumer: Flag is true, processing..."
  end
end

threads.each(&:join)

在这个例子中，condition.wait 和 condition.signal 用于线程间的通信：

  • 生产者线程：通过 condition.signal 通知消费者线程。
  • 消费者线程：等待直到条件成立（flag == true）。

🔹 使用线程池

线程池是为了避免频繁地创建和销毁线程而提供的线程管理方法。使用线程池可以有效地控制线程的数量，提高资源利用率。

Ruby 没有内置的线程池实现，但可以通过一些外部库实现。常见的线程池库包括 concurrent-ruby。

使用 concurrent-ruby 实现线程池

gem install concurrent-ruby


require 'concurrent-ruby'

pool = Concurrent::FixedThreadPool.new(5)

5.times do |i|
  pool.post do
    puts "Task #{i} is running"
    sleep 1
  end
end

pool.shutdown
pool.wait_for_termination
puts "All tasks completed"

在这个例子中：

  • Concurrent::FixedThreadPool.new(5) 创建了一个最大并发数为 5 的线程池。
  • pool.post 用于将任务提交到线程池中执行。

🔹 示例代码：多线程应用

多线程爬虫示例

require 'net/http'
require 'thread'

urls = ['http://example.com', 'http://example.org', 'http://example.net']
mutex = Mutex.new

threads = []

urls.each do |url|
  threads << Thread.new do
    response = Net::HTTP.get(URI(url))
    mutex.synchronize do
      puts "Fetched from #{url}: #{response[0..100]}"  # 打印前 100 个字符
    end
  end
end

threads.each(&:join)
puts "All URLs fetched"

这个示例展示了如何使用多线程并发地爬取多个网站的内容。每个线程请求一个 URL，并打印响应的前 100 个字符。

🔹 常见问题

1. 如何处理线程异常？

每个线程可能会遇到异常。你可以在每个线程中使用 begin...rescue 来捕获异常，确保线程不会因为错误而终止。

threads << Thread.new do
  begin
    # 可能会抛出异常的代码
  rescue => e
    puts "Error in thread: #{e.message}"
  end
end

2. 如何处理线程的优先级和调度？

Ruby 并没有直接提供控制线程优先级的机制。线程调度通常是由操作系统控制。通过合理的线程同步和合理的资源分配来保证程序的效率。

3. 多线程和并行处理的区别？

多线程是在同一进程中并发执行多个线程，但它们共享相同的内存空间。而并行处理通常指的是多个独立进程在多个 CPU 核心上同时执行，通常不共享内存。

🔹 参考资料

总结

  • Ruby 提供了 Thread 类来支持多线程编程，可以用于并发执行多个任务。
  • 线程的创建和管理非常简单，通过 Thread.new 来启动线程，通过 join 等待线程完成。
  • 为了避免多线程中的数据竞争问题，可以使用 Mutex 和 ConditionVariable 来实现线程同步。
  • 线程池是一种有效的方式来管理大量线程，可以避免频繁创建销毁线程的开销。

通过合理使用多线程，您可以提高程序的效率，尤其是在需要并发处理 I/O 或 CPU 密集型任务时。