6

当我第一次发现线程时，我尝试通过在许多线程中调用 sleep 来检查它们是否确实按预期工作，而不是正常调用 sleep。它奏效了，我很高兴。

但后来我的一个朋友告诉我，这些线程并不是真正并行的，睡眠一定是在假装它。

所以现在我写了这个测试来做一些真正的处理：

class Test
  ITERATIONS = 1000

  def run_threads
    start = Time.now

    t1 = Thread.new do
      do_iterations
    end

    t2 = Thread.new do
      do_iterations
    end

    t3 = Thread.new do
      do_iterations
    end

    t4 = Thread.new do
      do_iterations
    end

    t1.join
    t2.join
    t3.join
    t4.join

    puts Time.now - start
  end

  def run_normal
    start = Time.now

    do_iterations
    do_iterations
    do_iterations
    do_iterations

    puts Time.now - start
  end

  def do_iterations
    1.upto ITERATIONS do |i|
      999.downto(1).inject(:*) # 999!
    end
  end
end

现在我很伤心，因为 run_threads() 不仅没有比 run_normal 表现好，它甚至更慢！

那么，如果线程不是真正并行的，我为什么要让我的应用程序复杂化呢？

** 更新 **

@fl00r 说如果我将线程用于 IO 任务，我可以利用它们，所以我又写了两个 do_iterations 变体：

def do_iterations
  # filesystem IO
  1.upto ITERATIONS do |i|
    5.times do
      # create file
      content = "some content #{i}"
      file_name = "#{Rails.root}/tmp/do-iterations-#{UUIDTools::UUID.timestamp_create.hexdigest}"
      file = ::File.new file_name, 'w'
      file.write content
      file.close

      # read and delete file
      file = ::File.new file_name, 'r'
      content = file.read
      file.close
      ::File.delete file_name
    end
  end
end

def do_iterations
  # MongoDB IO (through MongoID)
  1.upto ITERATIONS do |i|
    TestModel.create! :name => "some-name-#{i}"
  end
  TestModel.delete_all
end

性能结果还是一样：正常>线程。

但现在我不确定我的虚拟机是否能够使用所有内核。当我测试过它时会回来。

4

5 回答 5

7

只有当你有一些缓慢的 IO 时，线程才能更快。

在 Ruby 中，您有全局解释器锁，因此一次只能工作一个线程。因此，Ruby 花费很多时间来管理应该立即触发哪个线程（线程调度）。因此，在您的情况下，当没有任何 IO 时，它会变慢！

您可以使用 Rubinius 或 JRuby 来使用真正的线程。

IO 示例：

module Test
  extend self

  def run_threads(method)
    start = Time.now

    threads = []
    4.times do
      threads << Thread.new{ send(method) }
    end

    threads.each(&:join)

    puts Time.now - start
  end

  def run_forks(method)
    start = Time.now

    4.times do
      fork do
        send(method)
      end
    end
    Process.waitall

    puts Time.now - start
  end

  def run_normal(method)
    start = Time.now

    4.times{ send(method) }

    puts Time.now - start
  end

  def do_io
    system "sleep 1"
  end

  def do_non_io
    1000.times do |i|
      999.downto(1).inject(:*) # 999!
    end
  end
end

Test.run_threads(:do_io)
#=> ~ 1 sec
Test.run_forks(:do_io)
#=> ~ 1 sec
Test.run_normal(:do_io)
#=> ~ 4 sec

Test.run_threads(:do_non_io)
#=> ~ 7.6 sec
Test.run_forks(:do_non_io)
#=> ~ 3.5 sec
Test.run_normal(:do_non_io)
#=> ~ 7.2 sec

IO 作业在线程和进程中快 4 倍，而非 IO 作业在进程中的速度是线程和同步方法的两倍。

同样在 Ruby 中提供了Fibers轻量级“协程”和很棒的 em-synchrony gem来处理异步进程

于 2012-04-19T10:30:41.227 回答
5

fl00r 是对的，全局解释器锁防止了 ruby​​ 中多个线程同时运行，IO 除外。

该parallel库是一个非常简单的库，可用于真正的并行操作。安装gem install parallel。这是重写以使用它的示例：

require 'parallel'
class Test
  ITERATIONS = 1000

  def run_parallel()
    start = Time.now

    results = Parallel.map([1,2,3,4]) do |val|
        do_iterations
    end

    # do what you want with the results ...
    puts Time.now - start
  end

  def run_normal
    start = Time.now

    do_iterations
    do_iterations
    do_iterations
    do_iterations

    puts Time.now - start
  end

  def do_iterations
    1.upto ITERATIONS do |i|
      999.downto(1).inject(:*) # 999!
    end
  end
end

在我的电脑（4 cpu）上，Test.new.run_normal需要 4.6 秒，而Test.new.run_parallel需要 1.65 秒。

于 2012-04-19T11:09:33.373 回答
4

线程的行为由实现定义。例如，JRuby 使用 JVM 线程实现线程，而 JVM 线程又使用真实线程。

Global Interpreter Lock仅出于历史原因而存在。如果 Ruby 1.9 只是突然引入了真正的线程，那么向后兼容性就会被破坏，并且会进一步减慢它的采用速度。

Jörg W Mittag的这个答案在各种 Ruby 实现的线程模型之间提供了很好的比较。选择适合您需要的一种。

话虽如此，线程可用于等待子进程完成：

pid = Process.spawn 'program'
thread = Process.detach pid

# Later...
status = thread.value.exitstatus
于 2012-04-19T12:19:15.080 回答
2

即使线程不并行执行，它们也可以是完成某些任务的一种非常有效、简单的方法，例如进程内 cron 类型的作业。例如：

Thread.new{ loop{ download_nightly_logfile_data; sleep TWENTY_FOUR_HOURS } }
Thread.new{ loop{ send_email_from_queue; sleep ONE_MINUTE } }
# web server app that queues mail on actions and shows current log file data

我还使用 DRb 服务器中的线程来处理我的一个 Web 应用程序的长时间运行的计算。Web 服务器在一个线程中开始计算并立即继续响应 Web 请求。它可以定期查看作业的状态并查看其进展情况。有关更多详细信息，请阅读DRb Server for Long-Running Web Processes。

于 2012-04-19T15:52:41.493 回答
1

要查看差异的简单方法，请使用 Sleep 而不是 IO，后者也依赖于太多变量：

class Test


ITERATIONS = 1000

  def run_threads
    start = Time.now
    threads = []

    20.times do
      threads << Thread.new do
        do_iterations
      end
    end

    threads.each {|t| t.join } # also can be written: threads.each &:join

    puts Time.now - start
  end

  def run_normal
    start = Time.now

    20.times do
      do_iterations
    end

    puts Time.now - start
  end

  def do_iterations
    sleep(10)
  end
end

即使在 MRB 上，这与 GIL 之间的线程解决方案也会有所不同

于 2013-03-09T08:08:49.580 回答