ruby 处理四个一组的数组元素

Question

当每个元素都需要处理时，我有一个 ruby​​ 脚本数组：

threads = []
elemets.each do  |element|
    threads.push(Thread.new{process(element)}}
end
threads.each { |aThread|  aThread.join }

然而，由于资源限制，如果一次不再处理四个元素，脚本会以最佳方式运行。

不，我知道我可以转储每个循环并使用变量来计算 4 个元素，然后等待 但是有没有更酷的 ruby​​ 方法呢？

Answer 1

您可以为数组枚举 4 个一组：

>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].each_slice(4) {|a| p a}
[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11, 12]

所以你可以尝试类似的东西

elements.each_slice(4) do | batch |
    batch.each do | element |
        threads.push(Thread.new{process(element)}}

    end
    (do stuff to check to see if the threads are done, otherwise wait )
end

不过，这可能不是您所需要的 - 我从凌晨 3 点就起床了，我只睡了几个小时。 ：/

Answer 2

如果我没看错的话，你希望一次处理的线程不超过 4 个。

在我看来，您应该只启动 4 个线程，并让它们全部从共享队列（标准线程库的一部分）中读取以处理元素。

您可以在队列为空时结束线程。

将数组分割成 4 个相等的数组，并让每个线程处理 1/4 的元素，假设每个元素同时处理。如果某些线程比其他线程花费更长的时间，那么您的某些线程将提前完成。

使用队列，在共享队列为空之前不会停止线程，所以我认为这是一个更有效的解决方案。

这是一个基于您的代码的工作程序来演示：

require 'thread'

elements = [1,2,3,4,5,6,7,8,9,10]

def process(element)
    puts "working on #{element}"
    sleep rand * 10
end

queue = Queue.new
elements.each{|e| queue << e }

threads = []
4.times do
    threads << Thread.new do
      while (e = queue.pop(true) rescue nil)
        process(e)
      end
    end
end

threads.each {|t| t.join }

Answer 3

在 rails（不是 Ruby）中，可以使用更易读的形式 in_groups_of

arr= [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
arr.in_groups_of(4, false) {|a| p a}

结果：

[1, 2, 3, 4]
[5, 6, 7, 8]
[9, 10, 11]

最后一行只有 3 个元素，因为我们在 in_group_of 中指定 false 作为第二个参数。如果您想要 nil 或任何其他值，您可以将 false 替换为该值。

Answer 4

不确定以下变体是否算作仅使用“计算 4 个元素的变量”，或者认为很酷，但它为您提供了一个大小不超过 4 个元素的切片数组：

x = (1..10).to_a
0.step(x.size - 1, 4) do |i|
    # Choose one
    p x.slice(i, 4)
    p x[i, 4]
end

Answer 5

是的，但是你需要做一些方法覆盖。通常的方法是像这样覆盖 Array 的“/”：

class Array
  def / len
    a = []
    each_with_index do |x,i|
      a << [] if i % len == 0
      a.last << x
    end
    a
  end
end 

有了这个定义，您现在可以轻松做到：

foo = [1,2,3,4,5,6]
foo / 2
# Result is [[1,2], [3,4], [5,6]]