l'impression étrange et même le nombre d'impression en alternance à l'aide de threads en C++
Étrange même nombre d'impression à l'aide de fil Je suis tombé sur cette question et je voulais discuter de la solution en C++ . Ce que je peux penser à l'aide de 2 sémaphores binaires paires et impaires de sémaphore. même sémaphore initialisé à 1 et de l'impair initialisé à 0.
**T1 thread function**
funOdd()
{
wait(even)
print odd;
signal(odd)
}
**T2 thread function**
funEven()
{
wait(odd)
print even
signal(even)
}
En plus de cela, si mes fonctions sont la génération de nombre et il y a un troisième fil T3 qui va imprimer ces numéros, ce qui devrait être la conception idéale ? J'ai utilisé un tableau où nombre impair sera placé à l'endroit bizarre et même le nombre aura lieu à la même position. T3 de lecture à partir de cet ensemble cela permettra d'éviter tout thread de sécurité sur ce tableau et si T3 ne trouve aucun indice puis il va attendre jusqu'à ce que l'index est renseigné. Une autre solution peut être d'utiliser une file d'attente qui aura un mutex qui peut être utilisé par T1 et T2 alors que d'insertion.
S'il vous plaît commentaire sur cette solution, et comment la rendre plus efficace.
Modifier pour rendre le problème bien clair: Globalement, le problème est que j'ai deux producteurs (T1,T2) et un consommateur (T3), et mes producteurs sont interdépendants.
Je peux l'éviter thread dans ce cas, mais c'est très valable scénario où mes 2 fils sont dépendantes les unes des autres.
J'essaie vraiment dur de suivre cette question et ont découvert que, sans code (un quasi-universelle de la langue, de l'enregistrer pour insolite var noms) la description est boueux à suivre, et dans certains endroits, quasi-impossible. regarde comme vous êtes deux producteurs (T1,T2) et un consommateur (T3), mais votre les producteurs sont interdépendants. Je suis aussi curieux de voir comment "si T3 ne trouve aucun indice puis il va attendre jusqu'à ce que l'index est renseigné." va tenir sans la synchronisation de genre. Enfin, "très valide"? Valide est un peu. Il est, ou il ne l'est pas.
T3 pouvez dormir pendant un certain temps et vérifiez de nouveau pour cet indice. si l'indice est peuplée, puis passer à la prochaine reste dormir à nouveau. Pourquoi pensez-vous que nous avons besoin de synchronisation pour le tableau Pouvez-vous m'expliquer un scénario où j'aurai besoin de synchronisation ?
cette question ont tout suivi? en fin de compte, quelle est votre réponse?
OriginalL'auteur user258367 | 2013-02-01
Vous devez vous connecter pour publier un commentaire.
À l'aide de condition_variable
t2
thread qui s'exécute en premier?PrintEven()
acquiert le verrou puis attend pour compter jusqu'à devenir même. Maiscount
est 1, et il deviendra encore seulement quandPrintOdd()
exécutecount++
.PrintOdd()
est en attente pour le verrouillage, de sorte que ne peut pas exécuter.OriginalL'auteur Ankur
Solution est basé sur le C++11 critique le code de la section aka mutex.
Voici le code de travail, suivie d'une explication.
Testé et de travail sur VS2013:
je.e:
Fil bizarre va à la méthode oddAndEven avec le numéro de départ 1 ainsi, il est impair. Il est le premier à acquérir le verrou qui est le
mtx.lock()
.Pendant ce temps, le fil Même essaie d'acquérir le verrou trop mais thread bizarre acquis d'abord fil Même attend.
Retour à fil bizarre (qui a la serrure), il imprime le numéro 1 et libère le verrou avec
mtx.unlock()
. À ce moment, nous voulons fil Même à acquérir verrouillage et imprimer 2 de sorte que nous en aviser au fil Même par écritstd::this_thread::yield()
. Puis de fil Même fait de même.etc etc etc.
Viens de tomber sur ce.Que faire si le rendement ne fait rien, je veux dire le même thread est prévu à nouveau.Puis l'ordonnance du changement.On peut obtenir
0 2 4 1 3...
Hey @GauravSehgal, je suis désolé mais je n'ai pas compris ce que tu voulais dire. Si vous pensez qu'il y a une erreur, vous pouvez modifier la réponse mais..
OriginalL'auteur OhadM
C'est la solution la plus simple, vous pouvez vous référer:
OriginalL'auteur Helping Bean
Je ne comprends pas pourquoi vous voulez utiliser trois threads séparés pour une série de comportement. Mais je vais répondre quand même:)
Une solution serait d'utiliser une version modifiée de producteur/consommateur avec un motif priorité de la file d'attente entre les producteurs et les consommateurs. L'opération de tri sur la file d'attente dépendra de la valeur de l'entier du message publié. Le consommateur coup d'oeil un élément dans la file d'attente et vérifier si elle est la prochaine devrait élément. Si non, il serait sommeil/wait.
Un peu de code:
plus ou moins de Java. La langue n'est pas pertinent, le derrière, il ne change pas
OriginalL'auteur Dariusz
Comme une première chose, les deux fonctions doivent au moins contenir une boucle, (sauf si vous voulez juste un numéro unique)
Plus de solution standard (qui redessine votre idée), c'est d'avoir une structure globale contenant un mutex, et deux variables de condition (pair et impair), plus une valeur de retour, et une autre condition pour l'impression. que d'utiliser un uique_lock pour gérer la synchronisation.
EN PSEUDO-CODE:
Noter que, mis à but didactique, cette solution n'ajoute pas de valeur à l'égard d'une simple boucle d'impression de la valeur d'un compteur, car il n'y aura jamais de véritable concurrence.
Note également (pour éviter les variables globales) que vous pouvez envelopper le tout dans une classe (l'principales d'une méthode de classe) et instantate cette classe sur la pile à l'intérieur de la nouvelle principale.
OriginalL'auteur Emilio Garavaglia
OriginalL'auteur Invictus
Veuillez voir ci-dessous le code de travail (VS2005)
Ici, en utilisant la variable partagée
shared_value
, nous sommes à la synchronisation de laeven_thread_cs
etodd_thread_cs
.Notez que le sommeil n'est pas utilisé.
OriginalL'auteur Vijay