Un thread est une seule unité d'exécution dans un programme. Un programme ordinaire est unique, où les instructions du programme s'exécutent successivement jusqu'à la résiliation.
D'un autre côté, le multi-threading permet au programme de créer plusieurs threads où les instructions d'un programme peuvent exécuter simultanément. Il offre une excellente utilisation des ressources système telles que le processeur et la mémoire.
Dans Ruby, nous utilisons des threads à l'aide de la classe Threads. Les fils de Ruby ne sont pas lourds des ressources, ce qui les rend efficaces pour utiliser la concurrence dans vos programmes.
Les threads sont implémentés dans l'interprète Ruby pour Ruby Version 1.9 et moins. À partir de la version 1.9 et plus, le filetage est implémenté sur le système d'exploitation.
En utilisant ce guide, vous apprendrez à implémenter des threads dans la programmation Ruby.
Point à noter: L'interprète de Matz (IRM) a un serrure d'interprète global qui empêche plusieurs threads d'exécuter simultanément. Cependant, cela ne s'applique pas aux interprètes JRuby et Rubinius.
Créer un fil
Comme mentionné, nous pouvons travailler avec des threads en utilisant la classe de threads. Pour créer un nouveau thread, appelez le fil.nouvelle méthode.
La syntaxe est:
Fil.Nouveau # Bloc thread va ici
Assurez-vous d'inclure le code que vous souhaitez avoir exécuté par le fil à l'intérieur de la paire de contreventements bouclés.
Voici un exemple:
Fil.Nouveau met "bonjour, monde!"
Prenons un programme simple qui calcule la zone d'un cercle.
zone DEF
pi = 3.14159
rad = 7.3
retour (pi * rad * rad)
fin
Fil.nouveau
zone()
met "courir à l'intérieur du fil!"
met "l'exécution complète!"
Si vous exécutez l'exemple ci-dessus, vous remarquerez que nous n'obtenons pas la zone du cercle. En effet, Ruby n'attend pas que les threads créés terminent l'exécution. Pour s'assurer que les threads se terminent, nous devons appeler la méthode de jointure.
La méthode de jointure en pause l'exécution du thread principal et attendra les threads spécifiés dans la méthode de jointure pour terminer.
Ce qui suit est l'exemple de code ci-dessus avec la méthode de jointure implémentée.
zone DEF
pi = 3.14159
rad = 7.3
retour (pi * rad * rad)
fin
thread = thread.nouveau
place "la zone du cercle est # zone () cm2"
met "courir à l'intérieur du fil!"
fil.rejoindre
met "l'exécution complète!"
Dans cet exemple, nous obtenons la sortie du thread comme indiqué ci-dessous:
La zone du cercle est 167.41533109999997 CM2
Coulant à l'intérieur du fil!
Exécution complète!
Terminer un fil
Ruby fournit différentes façons de terminer un fil. Une telle façon consiste à utiliser la méthode de mise à mort.
La syntaxe est:
Fil.tuer (fil)
Spécifiez le nom du fil pour se terminer à l'intérieur de la parenthèse.
Exceptions de fil
Vous remarquerez que si une exception se présente dans un fil, l'exécution du programme ne s'arrête pas.
Par exemple:
def error_me
Sauver "Erreur!"
fin
Fil.Nouveau error_me
met "je cours toujours"
Dans l'exemple ci-dessus, nous soulevons une exception à l'intérieur de la fonction transmise au fil. Vous remarquerez deux choses:
- Le thread n'affichera pas le message d'erreur
- Le code après le thread s'exécute toujours.
Dans certains cas, vous voudrez peut-être arrêter l'exécution si une exception se présente à l'intérieur d'un fil. Nous pouvons le faire en utilisant l'ABORT_ON_EXECPTION.
Par exemple:
Fil.abort_on_exception = true
thready = thread.new faire
met "je cours avant l'exception"
Sauver "Exception s'est produite!"
fin
époustouflant.rejoindre
met "désolé, je ne cours pas!"
Dans l'exemple ci-dessus, le programme se terminera si lorsqu'une exécution se produit à l'intérieur du thread. Voici un exemple de sortie:
Je cours avant exception
# terminé avec exception (report_on_exception est vrai):
threads.RB: 4: dans 'Block in': l'exception s'est produite! (Erreur d'exécution)
threads.RB: 4: dans 'Block in
': Il y a une exception! (Erreur d'exécution) Variables de thread
Les variables créées dans un thread obéissent aux règles de portée Ruby. Ils ne sont accessibles que dans le cadre du fil dans lequel ils sont créés.
États de threads
Vous pouvez récupérer l'état d'un thread donné en utilisant la méthode d'état. Vous pouvez également utiliser le vivant pour vérifier si le fil est en cours d'exécution et arrêter pour vérifier si le fil est mort.
Il y a cinq valeurs de retour pour la méthode d'état:
- En cours - Renvoie la course
- Dormir - Renvoie du sommeil
- Avorter - Retourne avorter
- Terminé avec exception - Renvoie nil
- Se terminer normalement - Renvoie faux.
Conclusion
Dans ce guide, nous avons discuté des bases du travail avec les threads dans le langage de programmation Ruby.
Il est bon de noter qu'il y a plus que ce dont nous avons discuté dans ce guide. Considérez la documentation pour en savoir plus.
Merci pour la lecture!
