Quelque chose que je ne comprends pas l'algorithme classique du problème producteur-consommateur (de Wikipedia :)multithreading: algorithme producteur-consommateur classique
semaphore mutex = 1
semaphore fillCount = 0
semaphore emptyCount = BUFFER_SIZE
procedure producer() {
while (true) {
item = produceItem()
down(emptyCount)
down(mutex)
putItemIntoBuffer(item)
up(mutex)
up(fillCount)
}
up(fillCount) //the consumer may not finish before the producer.
}
procedure consumer() {
while (true) {
down(fillCount)
down(mutex)
item = removeItemFromBuffer()
up(mutex)
up(emptyCount)
consumeItem(item)
}
}
Je constate que les producteurs et les consommateurs verrouillent « mutex » avant jouer avec le tampon, et le déverrouiller par la suite. Si tel est le cas, c'est-à-dire qu'un seul thread accède au tampon à un moment donné, je ne vois pas vraiment comment l'algo ci-dessus diffère d'une simple solution qui consiste à mettre un mutex de garde sur le tampon:
semaphore mutex = 1
procedure producer() {
while (true) {
item = produceItem()
flag = true
while (flag) {
down(mutex)
if (bufferNotFull()) {
putItemIntoBuffer(item)
flag = false
}
up(mutex)
}
}
}
procedure consumer() {
while (true) {
flag = true
while (flag) {
down(mutex)
if (bufferNotEmpty()) {
item = removeItemFromBuffer()
flag = false
}
up(mutex)
}
consumeItem(item)
}
}
La seule chose à laquelle je pense qui nécessite l'utilisation des sémaphores 'fillCount' et 'emptyCount' est programmant. Peut-être que le premier algo est pour s'assurer que dans un état où 5 consommateurs attendent sur un tampon vide (zéro 'fillCount'), il est assuré que quand un nouveau producteur arrive, il va passer son "down" (emptyCount) "déclaration rapidement et obtenir le« mutex »rapidement.
(alors que dans l'autre solution, les consommateurs auront inutilement le 'mutex' seulement pour l'abandonner jusqu'à ce que le nouveau producteur l'obtienne et insère un article).
Ai-je raison? Est-ce que je manque quelque chose?
Merci pour votre réponse rapide. Donc, lorsque j'utilise l'algorithme correct, je dois me fier aux opérations up(), down() pour ne pas écraser l'unité centrale ... Je veux dire qu'une prémisse de cet algorithme est que ces opérations ne le font pas magiquement, n'est-ce pas? – bloodcell
Oui, l'algorithme dépend du fait que, si le sémaphore est à zéro, l'opération 'down()' mettra le thread qui l'a appelé à dormir jusqu'à ce que quelqu'un appelle 'up()' sur le même sémaphore. –