Comment puis-je gérer ruby fils de sorte qu'ils finissent leur travail?

J'ai un calcul qui peut être divisé en unités indépendantes et la façon dont je m'occupe maintenant, c'est par la création d'un nombre fixe de threads et ensuite de passer au large de morceaux de travail à faire dans chaque thread. Donc, en pseudo-code, voici à quoi il ressemble

# main thread
work_units.take(10).each {|work_unit| spawn_thread_for work_unit}

def spawn_thread_for(work)
  Thread.new do
    do_some work
    more_work = work_units.pop
    spawn_thread_for more_work unless more_work.nil?
  end
end

Fondamentalement, une fois le nombre de threads est créé chacun fait un peu de travail et de garde, puis de prendre des trucs à faire à partir de la pile de travail jusqu'à ce qu'il ne reste rien. Tout fonctionne bien quand je lance des choses dans la cisr, mais quand j'execute le script à l'aide de l'interprète les choses ne fonctionnent pas si bien. Je ne suis pas sûr de savoir comment faire le thread principal attendez jusqu'à ce que le travail est terminé. Est-il une bonne façon de le faire ou suis-je coincé avec l'exécution de sleep 10 until work_units.empty? dans le thread principal

Ne pas take(10) dire que seuls les 10 premiers work_units seront traitées, jamais?
Grimm: en Fait non, mais en relisant la question, il ressemble à work_units serait hors de portée pour spawn_thread_for pour la ligne more_work = work_units.pop
Dans le code actuel, c'est une variable d'instance, donc il n'y a pas de délimitation de l'étendue des problèmes.

InformationsquelleAutor davidk01 | 2011-06-05

15

Si vous modifiez spawn_thread_for pour enregistrer une référence à votre Thread, alors vous pouvez appeler Thread#join sur le fil pour attendre l'achèvement:
```
x = Thread.new { sleep 0.1; print "x"; print "y"; print "z" }
a = Thread.new { print "a"; print "b"; sleep 0.2; print "c" }
x.join # Let the threads finish before
a.join # main thread exits...
```
produit:
```
abxyzc
```
(Vol à partir de la ri Thread.new de la documentation. Voir la ri Thread.join la documentation pour plus de détails.)

Donc, si vous modifier spawn_thread_for de sauver le Fil références, vous pouvez vous joindre à eux tous:

(Non testé, mais devrait donner de la saveur)
```
# main thread
work_units = Queue.new # and fill the queue...

threads = []
10.downto(1) do
  threads << Thread.new do
    loop do
      w = work_units.pop
      Thread::exit() if w.nil?
      do_some_work(w)
    end
  end
end

# main thread continues while work threads devour work

threads.each(&:join)
```
- Mais cela peut potentiellement faire threads assez grand parce que quand un thread se termine, il est la référence est toujours dans le threads tableau. En outre threads est en train d'être modifiée en cours de threads.each(&:join) est en cours d'exécution si ce n'est toujours pas à résoudre le problème.
- peut-être au lieu de l'appeler spawn_thread_for dans chaque thread, il suffit de regarder pour plus de travail et de commencer directement?
- Je veux seulement un nombre fixe de threads actifs. Si je cherche plus de travail et ensuite démarrer un thread c'est possible je peux le dépassement de la limite de 10 threads en raison de l'incertitude dans la façon dont la planification se passe, et la quantité de travail que chaque thread est en train de faire.
- démarrer un autre thread quand on est "terminé"? Il suffit de saisir une nouvelle unité de travail dans le déjà-thread en cours d'exécution. Démarrer dix threads et puis laissez-les commencer à sucer les unités de travail hors de votre file d'attente de travail. (Voir la Queue classe pour un thread-safe file d'attente de mise en œuvre.)
- grand point. Je n'avais pas pensé à ça, donc merci pour ça.
- Je l'ai ré-écrit la réponse un peu pour essayer de montrer ce que je veux dire, peut-être que ça va encore être utile. 🙂
- Pourquoi êtes-vous à l'aide de Thread::exit() plutôt que break?
InformationsquelleAutor sarnold
32

En ruby 1.9 (et 2.0), vous pouvez utiliser ThreadsWait de la stdlib à cet effet:
```
require 'thread'
require 'thwait'

threads = []
threads << Thread.new { }
threads << Thread.new { }
ThreadsWait.all_waits(*threads)
```
- Pouvez-vous expliquer la différence entre ThreadsWait.all_waits(*threads) et threads.each { |thr| thr.join }?
- La deuxième manière est la plus moderne de l'API.
InformationsquelleAutor esad
3

Il semble que vous répliquez que le Parallèle (Peach) bibliothèque.
- Je n'ai pas besoin de toute une bibliothèque pour le cas simple d'utilisation, j'ai dans l'esprit, mais merci pour le lien.
InformationsquelleAutor Hector Castro

Thread.list.each{ |t| t.join unless t == Thread.current }

InformationsquelleAutor brauliobo

0

Vous pouvez utiliser Thread#join

join(p1 = v1) public

Le thread suspendre l'exécution et exécuter thr. Ne pas revenir jusqu'à ce thr sort ou jusqu'à ce que la limite de secondes se sont écoulées. Si le délai expire, aucun ne sera retourné, sinon thr est retourné.

Vous pouvez également utiliser Énumérable#each_slice pour itérer sur les unités de travail dans les lots
```
work_units.each_slice(10) do |batch|
  # handle each work unit in a thread
  threads = batch.map do |work_unit|
    spawn_thread_for work_unit
  end

  # wait until current batch work units finish before handling the next batch
  threads.each(&:join)
end
```
InformationsquelleAutor Hirurg103

Vous devez vous connecter pour publier un commentaire.