Qu'est-ce que mutex et semaphore en Java? Quelle est la principale différence?

malheureusement tout le monde a manqué la différence la plus importante entre le sémaphore et le mutex; le concept de " propriété ".

n'ont aucune notion de propriété, ce qui signifie que n'importe quel fil peut libérer un sémaphore (cela peut conduire à de nombreux problèmes en soi mais peut aider à la"détection de la mort"). Alors qu'un mutex a le concept de propriété (i.e. vous ne pouvez libérer qu'un mutex que vous avez acquis).

La propriété est incroyablement importante pour la programmation sûre des systèmes concurrents. Je recommande toujours l'utilisation de mutex de préférence à un sémaphore (mais il y a des implications de performance).

peuvent aussi supporter l'héritage de priorité (ce qui peut aider avec le problème d'inversion de priorité) et la récursion (en éliminant un type d'impasse).

il convient également de souligner qu'il existe des sémaphores" binaires "et des sémaphores" comptage/général". Le Sémaphore de Java est un sémaphore de comptage et permet donc de l'initialiser avec une valeur supérieure à un (alors que, comme indiqué, un mutex ne peut compter qu'un seul). L'utilité de cette méthode a été soulignée dans d'autres postes.

donc pour résumer, à moins que vous ayez plusieurs ressources à gérer, je recommanderais toujours le mutex au-dessus du Sémaphore.

Mutex est essentiellement l'exclusion mutuelle. Un seul thread peut acquérir la ressource à la fois. Lorsqu'un thread acquiert la ressource, aucun autre thread n'est autorisé à acquérir la ressource jusqu'à ce que le thread propriétaire de la ressource versions. Tous les threads en attente d'acquisition de ressources seraient bloqués.

est utilisé pour contrôler le nombre de threads d'exécution. Il sera fixé ensemble de ressources. Le nombre de ressources sera décrémenté chaque fois qu'un fil possède la même. Lorsque le nombre de sémaphores atteint 0, aucun autre thread n'est autorisé à acquérir la ressource. Les threads sont bloqués jusqu'à ce que d'autres threads possédant des ressources libèrent.

en bref, la principale différence est combien de threads sont autorisés à acquérir la ressource à la fois ?

• Mutex --son un.
• Sémaphore-son DEFINED_COUNT, ( comme beaucoup de semaphore nombre)

Un mutex est utilisé pour la série de l'accès à une ressource alors qu'un sémaphore limite l'accès à une ressource à un nombre. Vous pouvez penser à un mutex comme un sémaphore avec un nombre d'accès de 1. Peu importe à quoi vous définissez votre compte de sémaphore, les threads de may peuvent accéder à la ressource avant que celle-ci ne soit bloquée.

un sémaphore est un mécanisme de synchronisation de comptage, pas un mutex.

Un mutex est souvent connu comme un sémaphore binaire. Alors qu'un sémaphore peut être créé avec n'importe quel nombre non-zéro, un mutex est conceptuellement un sémaphore avec un nombre supérieur de 1.

cette question a des réponses pertinentes et un lien vers le guide officiel de Java: y a-t-il un Mutex en Java?

vous comparez l'incomparable, techniquement il n'y a pas de différence entre un sémaphore et un mutex ça n'a pas de sens. mutex c'est juste un nom significatif comme n'importe quel nom dans la logique de votre application, ça veut dire que vous initialiser un sémaphore à "1", Il est généralement utilisé pour protéger une ressource ou une variable protégée pour assurer l'exclusion mutuelle.

Mutex est un sémaphore binaire. Il doit être initialisé avec 1, de sorte que le principe du premier arrivé, premier servi soit respecté. Cela nous amène à l'autre propriété particulière de chaque mutex: celui qui fait vers le bas , doit être quelqu'un qui ne . Par conséquent, nous avons obtenu l'exclusion mutuelle sur une certaine ressource.

Maintenant vous pouvez voir qu'un mutex est un cas particulier du général de sémaphore.

L'objet de la synchronisation Sémaphore met en œuvre un classique de la circulation de la lumière. Un feu de circulation contrôle l'accès à une ressource partagée par un comptoir. Si le compteur est supérieur à zéro, l'accès est accordé; Si elle est égale à zéro, l'accès est refusé. Le compteur compte les autorisations qui permettent d'accéder à la ressource partagée. Ensuite, pour accéder à la ressource, un thread doit recevoir l'Autorisation du feu de circulation. En général, pour utiliser un feu de circulation, le fil qui veut accès la ressource partagée tente d'obtenir un permis. Si le nombre de feux de circulation est supérieur à zéro, le fil obtient un permis, et le nombre de feux de circulation est décrémenté. Sinon, le fil est verrouillé jusqu'à ce qu'il peut obtenir une autorisation. Lorsque le thread n'a plus besoin d'accéder à la ressource partagée, il libère la permission, de sorte que le nombre de feux de circulation est augmenté. Si il y a un autre thread attente d'un permis, il acquiert un permis à l'époque. La classe sémaphore de Java implements ceci mécanisme.

sémaphore a deux constructeurs:

Semaphore(int num)
Semaphore(int num, boolean come)

num indique le nombre initial du permis. Ensuite, nombre spécifie le nombre de threads qui peuvent accéder à une ressource partagée à un moment donné. Si num est un, il peut accéder à la ressource un seul thread à la fois. En paramétrant come comme true, vous pouvez garantir que les threads que vous attendez soient autorisés dans l'ordre où ils ont été demandés.

sémaphore :

un sémaphore de comptage. Sur le plan conceptuel, un sémaphore maintient un ensemble de permis. Chaque acquire() bloque si nécessaire jusqu'à ce qu'un permis soit disponible, puis le prend. Chaque release() ajoute un permis, libérant potentiellement un acquéreur bloquant. Cependant, aucun objet de permis réel n'est utilisé; le sémaphore se contente de compter le nombre disponible et agit en conséquence.

les sémaphores sont souvent utilisés pour restreindre le nombre de threads qui peuvent accéder à certaines ressources (physiques ou logiques)

Java n'a pas d'API Mutex intégrée. Mais il peut être implémenté comme sémaphore binaire.

un sémaphore initialisé à un, et qui est utilisé de telle sorte qu'il n'a qu'un seul permis disponible, peut servir de verrouillage d'exclusion mutuelle. Ceci est plus communément connu comme un sémaphore binaire, parce qu'il a seulement deux états: un permis, ou zéro de permis disponibles.

lorsqu'il est utilisé de cette façon, le sémaphore binaire a la propriété (contrairement à de nombreuses implémentations de serrures), que la" serrure "peut être libérée par un fil autre que le propriétaire (comme les sémaphores n'ont aucune notion de propriété) . Cela peut être utile dans certains contextes spécialisés, comme la récupération de l'impasse.

Donc différences fondamentales entre sémaphore et Mutex:

1. sémaphore restreindre le nombre de threads pour accéder à une ressource par le biais de permis. Mutex ne permet qu'un seul thread pour accéder à la ressource.

2. aucun fil ne possède de sémaphore. Les Threads peuvent mettre à jour le nombre de permis en appelant les méthodes acquire() et release() . Les Mutex ne doivent être déverrouillés que par le fil qui retient la serrure.

3. Quand un mutex est utilisé avec des variables de condition, il y a une bracket implicite-il est clair quelle partie du programme est protégée D. Ce n'est pas nécessairement le cas pour un sémaphore, qui pourrait être appelé le aller à de la programmation concurrente -il est puissant mais trop facile à utiliser d'une manière non structurée, indéterminée.