Mon processus a deux fils comme les suivantssynchronisation des threads Ruby
@semaphore = Mutex.new
.
.
.
.
thread_a = Thread.new {
loop do
#some work
if(some_condition)
@semaphore.synchronize {
@thread_b_running = false
}
end
end
}
thread_b = Thread.new {
while(@semaphore.synchronize { @thread_b_running }) do
#thread_b's work
end
}
thread_a.join
thread_b.join
Fondamentalement, thread_a
et thread_b
faire un travail en parallèle, mais quand thread_a
voit un événement se produit, il doit fermer thread_b
. Comme vous pouvez le voir maintenant, je le fais en utilisant un booléen protégé par un mutex. Je pense que cette approche n'est pas trop mauvaise performance sage puisque thread_b
obtiendra presque toujours le verrou sans l'attendre. Cependant, puisque je n'ai pas écrit beaucoup de code multithread je me demandais s'il y avait une meilleure façon de faire ce que je fais?
Je pensais à cela mais cela ne poserait-il pas problème étant donné que l'écriture dans la variable n'est pas une opération atomique? Que se passe-t-il si thread_a écrit partiellement dans cette variable quand thread_a est supprimé du cpu thread_b est planifié? – Wooser990
@ Wooser990 Corrigez-moi si je me trompe, mais écrire dans une variable est une opération atomique (citation nécessaire). Même si ce n'est pas le cas, puisque c'est un booléen, dans le pire des cas, thread_b s'exécutera une fois de plus - le même cas de changement 'thread_b_running' à de vrais moments avant que le thread B commence à tourner. Correct? – fotanus
Une écriture dans une variable n'est pas une opération atomique http://moonbase.rydia.net/mental/blog/programming/atomic-operations-in-ruby.html. Cependant vous avez raison que dans mon cas, le pire des cas est le code thread_b qui s'exécute pour une itération supplémentaire (ce qui dans mon cas est acceptable). J'ai accepté votre réponse – Wooser990