Qu’est-ce qu’un mutex et un sémaphore en Java? Quelle est la principale différence?

Qu’est-ce qu’un mutex et un sémaphore en Java? Quelle est la principale différence?

    Le sémaphore peut être compté, tandis que le mutex ne peut compter que pour 1.

    Supposons que vous ayez un thread en cours d’exécution qui accepte les connexions client. Ce thread peut gérer 10 clients simultanément. Ensuite, chaque nouveau client définit le sémaphore jusqu’à ce qu’il atteigne 10. Lorsque le sémaphore a 10 indicateurs, votre thread n’acceptera pas de nouvelles connexions.

    Mutex sont généralement utilisés pour garder des choses. Supposons que vos 10 clients puissent accéder à plusieurs parties du système. Vous pouvez ensuite protéger une partie du système avec un mutex, de sorte que lorsque 1 client est connecté à ce sous-système, personne d’autre ne devrait avoir access. Vous pouvez également utiliser un sémaphore à cette fin. Un mutex est un “sémaphore d’exclusion mutuelle” .

    Malheureusement, tout le monde a manqué la différence la plus importante entre le sémaphore et le mutex; le concept de ” propriété “.

    Les sémaphores n’ont aucune notion de propriété, cela signifie que tout thread peut libérer un sémaphore (cela peut conduire à de nombreux problèmes en soi mais peut aider à “détecter les décès”). Alors qu’un mutex a le concept de propriété (c’est-à-dire que vous ne pouvez libérer qu’un mutex que vous avez acquis).
    La propriété est extrêmement importante pour la programmation sécurisée des systèmes concurrents. Je recommande toujours d’utiliser le mutex de préférence à un sémaphore (mais il y a des implications de performance).

    Les mutex peuvent également prendre en charge l’inheritance prioritaire (ce qui peut aider à résoudre le problème de l’inversion de priorité) et la récursivité (en éliminant un type de blocage).

    Il convient également de noter qu’il existe des sémaphores “binarys” 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 avoir qu’un seul compte conceptuel). L’utilité de ceci a été signalée dans d’autres articles.

    Donc, pour résumer, à moins que vous ayez plusieurs ressources à gérer, je recommanderais toujours le mutex sur le sémaphore.

    Mutex est fondamentalement une 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’au thread propriétaire des ressources. Tous les threads en attente d’acquisition de ressources seraient bloqués.

    Sémaphore est utilisé pour contrôler le nombre de threads en cours d’exécution. Il y aura un ensemble fixe de ressources. Le nombre de ressources sera décrémenté chaque fois qu’un thread possède le 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 versions de ressources.

    En bref, la principale différence est le nombre de threads autorisés à acquérir la ressource à la fois?

    • Mutex – c’est UN.
    • Sémaphore – son DEFINED_COUNT, (autant que le nombre de sémaphores)

    Un mutex est utilisé pour un access en série à une ressource, tandis qu’un sémaphore limite l’access à une ressource à un nombre défini. Vous pouvez considérer un mutex comme un sémaphore avec un nombre d’access de 1. Quoi que vous définissiez sur votre compte de sémaphores, les threads peuvent accéder à la ressource avant que la ressource ne soit bloquée.

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

    Un mutex est souvent appelé sémaphore binary. Alors qu’un sémaphore peut être créé avec un compte différent de zéro, un mutex est conceptuellement un demi-nombre avec un compte supérieur de 1.

    Cette question a des réponses pertinentes et un lien vers les instructions Java officielles: existe-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, cela n’a pas de sens. mutex c’est juste un nom significatif comme n’importe quel nom dans la logique de votre application, cela signifie que vous initialisez 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 binary. 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 a baissé doit être celui qui le fait . Ergo nous avons obtenu une exclusion mutuelle sur certaines ressources.

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

    L’object de la synchronisation Semaphore implémente un feu de signalisation classique. Un feu de signalisation contrôle l’access à une ressource partagée par un compteur. Si le compteur est supérieur à zéro, l’access est accordé; S’il est égal à zéro, l’access est refusé. Le compteur compte les permissions permettant d’accéder à la ressource partagée. Ensuite, pour accéder à la ressource, un thread doit recevoir l’autorisation du feu de signalisation. En général, pour utiliser un feu de signalisation, le thread qui souhaite accéder à la ressource partagée essaie d’acquérir un permis. Si le nombre de feux de signalisation est supérieur à zéro, le thread acquiert une autorisation et le nombre de feux de signalisation est décrémenté. Sinon, le thread est verrouillé jusqu’à ce qu’il puisse obtenir une autorisation. Lorsque le thread n’a plus besoin d’accéder à la ressource partagée, il libère l’autorisation, ce qui augmente le nombre de voyants. S’il y a un autre sujet en attente d’un permis, il acquiert un permis à ce moment-là. La classe Semaphore de Java implémente ce mécanisme.

    Semaphore a deux constructeurs:

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

    num spécifie le compte initial du permis. Puis num spécifie le nombre de threads pouvant accéder à une ressource partagée à un moment donné. Si num est un, il peut accéder à la ressource un thread à la fois. En définissant la valeur true, vous pouvez garantir que les threads que vous attendez sont autorisés dans l’ordre demandé.

    Sémaphore :

    Un sémaphore de comptage. Conceptuellement, un sémaphore maintient un ensemble de permis. Chacun acquire() 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 object d’autorisation réel n’est utilisé; le sémaphore ne tient compte que du nombre disponible et agit en conséquence.

    Les sémaphores sont souvent utilisés pour restreindre le nombre de threads pouvant accéder à une ressource (physique ou logique)

    Java n’a pas d’API Mutex intégrée. Mais il peut être implémenté sous forme de sémaphore binary.

    Un sémaphore initialisé à un, et qui est utilisé de telle sorte qu’il ne dispose au maximum que d’un seul permis, peut servir de locking d’exclusion mutuelle. Ceci est plus communément appelé un sémaphore binary, car il ne comporte que deux états: un permis disponible ou zéro permis disponible.

    Utilisé de cette manière, le sémaphore binary a la propriété (contrairement à de nombreuses implémentations de Lock) que le “verrou” peut être libéré par un thread autre que le propriétaire (car les sémaphores n’ont aucune notion de propriété) . Cela peut être utile dans certains contextes spécialisés, tels que la récupération des blocages.

    Donc, les principales différences entre Semaphore et Mutex:

    1. Sémaphore restreindre le nombre de threads pour accéder à une ressource grâce à un permis. Mutex permet à un seul thread d’accéder aux ressources.

    2. Aucun fil ne possède Semaphore. Les threads peuvent mettre à jour un certain nombre d’permissions en appelant les méthodes acquire() et release() . Les mutex ne doivent être déverrouillés que par le fil tenant le verrou.

    3. Lorsqu’un mutex est utilisé avec des variables de condition, il existe une parenthèse implicite – il est clair quelle partie du programme est protégée d. Ce n’est pas forcément le cas pour un sémaphore, que l’on pourrait appeler la programmation concurrente: elle est puissante mais trop facile à utiliser de manière indéterminée et non structurée.