Ruby 多线程（超详细）

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

• 新项目:《从零手撸：仿小红书（微服务架构）》 正在持续爆肝中，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;
• 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 82w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 2900+ 小伙伴加入学习 ，欢迎点击围观

在编程世界中，Ruby 多线程如同一支训练有素的团队，让程序在看似单核的CPU上也能高效地“同时”完成多个任务。无论是加速网络请求、优化资源密集型计算，还是提升用户交互体验，多线程技术始终是开发者手中的利器。本文将从基础概念到实战案例，逐步揭开 Ruby 多线程的奥秘，并帮助读者理解其应用场景与潜在挑战。

什么是多线程？线程与进程的区别

线程：程序中的“微型工作者”

线程（Thread）是程序内部的执行单元，可以理解为一个独立的“微型工作者”。一个进程（Process）可以包含多个线程，这些线程共享同一块内存空间和资源，但各自拥有独立的执行路径。例如，一个文本编辑器可能用主线程响应用户输入，同时用其他线程在后台自动保存文件或检查拼写错误。

线程与进程的核心区别

线程的比喻：生产线上的工人

想象一个工厂的生产线：整个工厂是一个进程，而每个工人（线程）负责不同的工序。例如，工人A组装零件，工人B测试产品，工人C包装货物。他们共享生产线上的原材料（内存资源），但各自独立完成任务。线程的协作正是如此，通过分工提升整体效率。

Ruby 多线程的核心概念与实现

创建与启动线程

在 Ruby 中，线程通过 Thread 类创建。以下是一个简单的示例，展示如何启动两个线程分别输出信息：

thread1 = Thread.new do  
  puts "线程1正在运行..."  
  sleep(1)  
end  

thread2 = Thread.new do  
  puts "线程2正在运行..."  
  sleep(2)  
end  

puts "主线程仍在运行"  

[thread1, thread2].each(&:join)  

执行结果可能为：

主线程仍在运行  
线程1正在运行...  
线程2正在运行...  

线程的生命周期

线程的生命周期包含以下状态：

可以通过 Thread.current.status 查看当前线程状态。

线程同步：避免竞态条件

竞态条件（Race Condition）

当多个线程同时访问共享资源（如计数器）并尝试修改时，若缺乏同步机制，可能导致不可预测的结果。例如：

counter = 0  

5.times do  
  Thread.new do  
    1000.times { counter += 1 }  
  end  
end  

Thread.list.each(&:join)  

puts "最终计数器值：#{counter}"  # 可能输出小于5000的值  

解决方案：使用 Mutex

Mutex（互斥锁）确保同一时间只有一个线程可以访问共享资源。修改代码后：

require 'thread'  

counter = 0  
mutex = Mutex.new  

5.times do  
  Thread.new do  
    1000.times do  
      mutex.synchronize do  
        counter += 1  
      end  
    end  
  end  
end  

Thread.list.each(&:join)  
puts "最终计数器值：#{counter}"  # 现在会稳定输出5000  

其他同步工具：Condition Variables

当线程需要等待某个条件满足时，可使用 ConditionVariable。例如，生产者-消费者模式：

require 'thread'  

buffer = []  
max_size = 5  
mutex = Mutex.new  
condition = ConditionVariable.new  

producer = Thread.new do  
  10.times do |i|  
    mutex.synchronize do  
      while buffer.size >= max_size  
        puts "缓冲区已满，生产者等待..."  
        condition.wait(mutex)  
      end  
      buffer << "Item #{i}"  
      puts "生产者添加：Item #{i}"  
      condition.signal  # 唤醒消费者  
    end  
    sleep(0.5)  
  end  
end  

consumer = Thread.new do  
  10.times do  
    mutex.synchronize do  
      while buffer.empty?  
        puts "缓冲区为空，消费者等待..."  
        condition.wait(mutex)  
      end  
      item = buffer.shift  
      puts "消费者取出：#{item}"  
      condition.signal  # 唤醒生产者  
    end  
    sleep(1)  
  end  
end  

[producer, consumer].each(&:join)  

Ruby 多线程的实战案例

案例1：并行下载多个URL

假设需要同时下载多个网页内容，单线程需逐个请求，而多线程可并行执行：

require 'open-uri'  

urls = [  
  'https://example.com/page1',  
  'https://example.com/page2',  
  'https://example.com/page3'  
]  

threads = urls.map do |url|  
  Thread.new(url) do |u|  
    puts "开始下载：#{u}"  
    content = open(u).read  
    puts "下载完成：#{u}，大小：#{content.size}字节"  
  end  
end  

threads.each(&:join)  

案例2：并行计算斐波那契数列

虽然 Ruby 的多线程对CPU密集型任务效果有限（因GIL限制），但可尝试对比：

def fibonacci(n)  
  return n if n <= 1  
  fibonacci(n-1) + fibonacci(n-2)  
end  

start = Time.now  
puts "单线程结果：#{fibonacci(35)}"  
puts "耗时：#{Time.now - start}秒"  

thread = Thread.new do  
  puts "多线程结果：#{fibonacci(35)}"  
end  
thread.join  
puts "多线程耗时：#{Time.now - start}秒"  

Ruby 多线程的局限性与注意事项

全局解释器锁（GIL）的影响

Ruby 的 MRI（官方实现）包含一个全局解释器锁（GIL），使得同一时刻只能有一个线程执行 Ruby 代码。这意味着：

• CPU密集型任务（如计算、加密）无法通过多线程加速，甚至可能因线程切换增加开销。
• IO密集型任务（如网络请求、文件读写）因线程在等待IO时会释放GIL，其他线程可执行，因此多线程有效。

如何选择多线程？

• 适合场景：并行执行IO操作、后台任务（如发送邮件、数据库查询）。
• 避免场景：纯计算任务（可考虑多进程或异步库如 concurrent-ruby）。

线程安全的最佳实践

1. 最小化共享资源：优先使用局部变量，避免全局状态。
2. 及时释放锁：确保 Mutex#synchronize 块尽可能短，减少线程等待时间。
3. 处理异常：在 begin-rescue 块中处理线程内的错误，避免崩溃影响主线程。

结论

Ruby 多线程如同一把双刃剑：它能显著提升程序在IO密集场景的效率，但也需要开发者谨慎处理同步问题和GIL的限制。通过合理设计线程结构、善用同步工具（如 Mutex 和 ConditionVariable），开发者可以安全地利用多线程的优势。未来，随着 Ruby 社区对并发模型的持续优化（如JRuby对多线程的更好支持），多线程技术的应用场景将更加广泛。

掌握多线程不仅是技术能力的提升，更是理解现代编程范式的重要一步。希望本文能为读者提供清晰的思路与实用的代码参考，助力在实际项目中高效运用 Ruby 多线程。