blocks|key|1155586|text|我不确定下面的变种是仅仅使用一个“变量来计算4个元素”，还是可以被认为很酷，但是它给了你一个大小不超过4个元素的切片数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1155587|x+=+(1..10).to_a
0.step(x.size+-+1,+4)+do+%7Ci%7C
++++#+Choose+one
++++p+x.slice(i,+4)
++++p+x[i,+4]
end|code-block|syntax|javascript|1155588|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Not sure if the following variant counts as just using a "variable to count 4 elements", or could be considered cool, but it gives you an array in slices of size no greater than 4 elements:

<pre><code>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
</code></pre>

blocks|key|1155642|text|是的，但是你需要做一些方法覆盖。通常的方法是覆盖Array的'/‘，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1155643|class+Array
++def+/+len
++++a+=+[]
++++each_with_index+do+%7Cx,i%7C
++++++a+<<+[]+if+i+%25+len+==+0
++++++a.last+<<+x
++++end
++++a
++end
end+|code-block|syntax|javascript|1155644|有了这个定义，您现在可以轻松地执行以下操作：|1155645|foo+=+[1,2,3,4,5,6]
foo+/+2
#+Result+is+[[1,2],+[3,4],+[5,6]]|1155646|entityMap^0|O|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Yes, but you need to do some method overriding. Usual approach is to override '/' for <code>Array</code> like so:

<pre><code>class Array
 def / len
 a = []
 each_with_index do |x,i|
 a &lt;&lt; [] if i % len == 0
 a.last &lt;&lt; x
 end
 a
 end
end 
</code></pre>

And with that defined you can now easily do:

<pre><code>foo = [1,2,3,4,5,6]
foo / 2
# Result is [[1,2], [3,4], [5,6]]
</code></pre>

blocks|key|1155684|text|您可以针对一个数组以4个为一组进行枚举：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1155685|>>+[1,+2,+3,+4,+5,+6,+7,+8,+9,+10,+11,+12].each_slice(4)+{%7Ca%7C+p+a}
[1,+2,+3,+4]
[5,+6,+7,+8]
[9,+10,+11,+12]|code-block|syntax|javascript|1155686|所以你可以尝试像这样的东西|1155687|elements.each_slice(4)+do+%7C+batch+%7C
++++batch.each+do+%7C+element+%7C
++++++++threads.push(Thread.new{process(element)}}

++++end
++++(do+stuff+to+check+to+see+if+the+threads+are+done,+otherwise+wait+)
end|1155688|不过，这可能不是你需要的--我从凌晨3点就起床了，只睡了几个小时。:/|1155689|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can enumerate in groups of 4 for an array:

<pre><code>&gt;&gt; [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]
</code></pre>

So you can try something like

<pre><code>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
</code></pre>

Its may not be what you need, though - I have been up since 3 AM and I only had a couple of hours sleep. :/

blocks|key|1370816|text|如果我没看错的话，您希望一次处理的线程不超过4个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1370817|在我看来，您应该只启动4个线程，并让它们都从共享队列(标准线程库的一部分)中读取，以处理这些元素。|1370818|您可以让线程在队列为空时结束。|1370819|将数组分成4个相等的数组，并让每个线程处理1/4的元素，假设每个元素在相同的时间内处理。如果某些线程花费的时间比其他线程长，那么您的一些线程将提前完成。|1370820|使用队列，没有线程停止，直到共享队列为空，所以我认为这是一个更有效的解决方案。|1370821|以下是一个基于您的代码的工作程序，用于演示：|1370822|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{%7Ce%7C+queue+<<+e+}

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

threads.each+{%7Ct%7C+t.join+}|code-block|syntax|javascript|1370823|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|V|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|W|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|X|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|Y|8|@]|9|@]|A|$O|P]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

If I read you right, you want to have no more than 4 threads processing at a time.

Sounds to me like you should launch only 4 threads, and have them all read from a shared Queue (part of the standard thread lib) to process the elements.

You can have the threads end when the queue is empty.

Slicing the array into 4 equal arrays, and having each thread process 1/4 of the elements assumes that each element processes in the same time. If some take longer than others, some of your threads will finish early. 

Using a queue, no thread stops until the shared queue is empty, so it is I think a more efficient solution.

Here is a working program based on your code to demonstrate:

<pre><code>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 &lt;&lt; e }

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

threads.each {|t| t.join }
</code></pre>

I have a ruby script array when each element needs processing :

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

how ever due to resource limitations, the script works in an optimal way if no more the four elements are processed at a time. 

no I know I can dump the each loop and use a variable to count 4 elements and then wait 
but is there a cooler ruby way to do it ?

ruby working on array elements in groups of four

当每个元素都需要处理时，我有一个ruby脚本数组：threads = []elemets.each do  |element|    threads.push(Thread.new{process(element)}}endthreads.each { |aThread|  aThread.join }然而，由于资源的...

问ruby以四个为一组处理数组元素
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问ruby以四个为一组处理数组元素EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问ruby以四个为一组处理数组元素
EN