CountDownLatch vs Sémaphore
Est-il un avantage de l'utilisation de
java.util.de façon concomitante.CountdownLatch
au lieu de
java.util.de façon concomitante.Sémaphore?
Autant que je peux dire fragments sont presque équivalents:
1. Sémaphore
final Semaphore sem = new Semaphore(0);
for (int i = 0; i < num_threads; ++ i)
{
Thread t = new Thread() {
public void run()
{
try
{
doStuff();
}
finally
{
sem.release();
}
}
};
t.start();
}
sem.acquire(num_threads);
2: CountDownLatch
final CountDownLatch latch = new CountDownLatch(num_threads);
for (int i = 0; i < num_threads; ++ i)
{
Thread t = new Thread() {
public void run()
{
try
{
doStuff();
}
finally
{
latch.countDown();
}
}
};
t.start();
}
latch.await();
Sauf que dans le cas n ° 2 le verrou ne peut pas être réutilisé et plus important encore, vous avez besoin de savoir à l'avance combien de threads sera créé (ou attendre jusqu'à ce qu'ils sont tout a commencé avant la création de l'loquet.)
Donc dans quelle situation pourrait le loquet être préférable?
Vous devez vous connecter pour publier un commentaire.
Compte à rebours loquet est fréquemment utilisé pour l'exact opposé de votre exemple. En général, vous disposez de nombreux fils de blocage sur "await()" qui commencent tous à la fois lorsque le countown atteint zéro.
Vous pouvez également l'utiliser comme un MPI de style "barrière" qui provoque tous les threads pour attendre les autres threads pour attraper jusqu'à un certain point avant de continuer.
Que tout est dit, le compte à Rebours loquet peut en toute sécurité être utilisé de la manière dont vous avez fait preuve dans votre exemple.
CountDownLatch est utilisé pour lancer une série de fils et ensuite, attendre jusqu'à ce que tous d'entre eux sont complets (ou jusqu'à ce qu'ils appellent
countDown()
un nombre donné de fois.Sémaphore est utilisé pour contrôler le nombre de threads simultanés qui sont l'utilisation d'une ressource. Cette ressource peut être quelque chose comme un fichier, ou peut être le cpu qui limite le nombre de threads en cours d'exécution. Le comte sur un Sémaphore peut aller en haut et en bas, comme les différents threads d'appel
acquire()
etrelease()
.Dans votre exemple, vous êtes essentiellement en utilisant un Sémaphore comme une sorte de ComteJUSQU'Loquet. Étant donné que votre intention est d'attendre sur tous les fils de finition, à l'aide de la
CountdownLatch
rend votre intention plus claire.Résumé court:
Sémaphore et CountDownLatch sert un but différent.
Utilisation Sémaphore de contrôle de fil d'accès à la ressource.
Utilisation CountDownLatch attendre la fin de tous les threads
Sémaphore définition de la documentation javadoc:
Cependant, aucun permis objets sont utilisés; le Sémaphore ne cesse de le nombre disponibles et agit en conséquence.
Comment ça fonctionne ?
Les sémaphores sont utilisés pour contrôler le nombre de threads simultanés qui sont l'utilisation d'une ressource.Cette ressource peut être quelque chose comme un partage de données, ou un bloc de code (section critique) ou tout autre fichier.
L'compter sur un Sémaphore peut aller en haut et en bas, comme les différents threads d'appel
acquire
() etrelease
(). Mais, à tout moment, vous ne pouvez pas avoir plus de nombre de threads de plus de Sémaphore comte.Sémaphore cas d'Utilisation:
concurrence disque cherche)
Jetez un oeil à cette l'article de sémaphore utilise.
CountDownLatch définition de la documentation javadoc:
Comment ça fonctionne?
CountDownLatch fonctionne en ayant un compteur initialisé avec le nombre de threads, ce qui est décrémenté à chaque fois qu'un thread terminer son exécution. Lorsque le compteur atteint zéro, cela signifie que tous les threads ont terminé leur exécution, et de fil en attente sur le loquet de reprendre l'exécution.
CountDownLatch cas d'Utilisation:
threads en même temps pour atteindre le maximum de parallélisme
Jetez un oeil à cette l'article à comprendre CountDownLatch clairement des concepts.
Ont un coup d'oeil à Fourche Rejoindre La Piscine à ce l'article trop. Il a quelques similitudes avec CountDownLatch.
Dire que vous êtes entré dans le golf pro shop, en espérant trouver un quatuor,
Quand vous êtes debout en ligne pour obtenir une heure de départ de l'un de la boutique du pro, les agents de bord, essentiellement, vous appelle
proshopVendorSemaphore.acquire()
, une fois que vous obtenez une heure de départ, vous avez appeléproshopVendorSemaphore.release()
.Note: tous les de la gratuit des standards de service vous, c'est à dire de la ressource partagée.Maintenant, vous marchez jusqu'à starter, il commence une
CountDownLatch(4)
et les appelsawait()
à attendre pour les autres, pour votre part, vous l'avez appelé le check-in c'est à direCountDownLatch
.countDown()
donc il ne reste du quatuor. Quand arrivent tous, le démarreur donne à aller de l'avant(await()
retours d'appel)Maintenant, après neuf trous et chacun de vous de prendre une pause, à titre d'hypothèse permet d'impliquer starter de nouveau, il utilise un "nouveau"
CountDownLatch(4)
au départ du Trou 10, de même attendre/sync en tant que Trou 1.Toutefois, si le démarreur utilisé un
CyclicBarrier
pour commencer, il aurait pu réinitialiser la même instance dans le Trou du 10 au lieu d'un deuxième verrou, qui utilisent & jeter.À la recherche à l'librement disponible source, il n'y a pas de magie dans la mise en œuvre des deux classes, de sorte que leur performance doit être la même. Choisissez celui qui fait que votre intention est de plus en plus évidents.
CountdownLatch fait threads attendent le attendent() la méthode, jusqu'à ce que le comte a atteint zéro. Alors peut-être que vous souhaitez que tous les threads d'attendre jusqu'à 3 invocations de quelque chose, alors tous les threads peuvent aller. Un Loquet ne peuvent généralement pas être remis à zéro.
Un Sémaphore permet aux threads pour récupérer le permet, ce qui empêche trop de threads de s'exécuter à la fois, de blocage si elle ne peut pas obtenir le permis(s) elle nécessite de procéder. Les permis peuvent être retournés pour un Sémaphore de permettre aux autres threads en attente de procéder.