La différence entre le binaire sémaphore mutex et de

Les Toilettes exemple est une bonne analogie:

Mutex:

Est une des clés d'un wc. Une personne peut
la clé - occuper le wc - au
le temps. Lorsque vous avez terminé, la personne
donne (libère) la clé de la prochaine
personne dans la file d'attente.

Officiellement: "les Mutex sont généralement
utilisé pour serialise l'accès à une section
de ré-entrant le code qui ne peut pas être
exécutées simultanément par plus d'un
fil de discussion. Un objet mutex permet uniquement d'un
fil dans une section contrôlée,
forcer les autres threads qui tentent de
accéder à cette section pour attendre
jusqu'à ce que le premier thread a quitté
cette section." Ref: Symbian Développeur
Bibliothèque

(Un mutex est vraiment un sémaphore avec
la valeur 1.)

Sémaphore:

Est le nombre de free identiques toilettes
les touches. Exemple, disons que nous avons quatre
les toilettes à l'identique des serrures et des clés.
Le sémaphore count - nombre de
touches - est fixé à 4 au début (tous les
quatre toilettes sont libres), puis le comte
la valeur est décrémentée que les gens sont
venir dans. Si toutes les salles sont pleines,
c'est à dire. il n'y a pas de libre-clés gauche, la
sémaphore nombre est 0. Maintenant, lors de l'eq.
une personne quitte les toilettes,
sémaphore est augmenté de 1 (un gratuitement
la clé), et donné à la prochaine personne dans
la file d'attente.

Officiellement: "Un sémaphore limite l'
nombre d'utilisateurs simultanés d'un
ressource partagée jusqu'à un maximum
numéro. Les Threads peuvent demander l'accès à
la ressource (décrémentation de la
sémaphore), et peut être le signal qu'ils
avez fini d'utiliser la ressource
(l'incrémentation du sémaphore)." Ref:
Symbian Développeur De La Bibliothèque

Bons articles sur le sujet:

• MUTEX VS. LES SÉMAPHORES – PARTIE 1: LES SÉMAPHORES
• MUTEX VS. LES SÉMAPHORES – PARTIE 2: LE MUTEX
• MUTEX VS. LES SÉMAPHORES – PARTIE 3 (DERNIÈRE PARTIE): PROBLÈMES DE L'EXCLUSION MUTUELLE

De la partie 2:

Le mutex est similaire aux principes
du sémaphore binaire avec un
différence significative: le principe
de la propriété. La propriété de la simple
concept que lorsqu'une tâche serrures
(acquiert) un mutex seulement il peut déverrouiller
(libération) il. Si une tâche essaie de
déverrouiller un mutex il n'a pas verrouillé (donc
ne les possède pas), alors une condition d'erreur
est rencontrés et, plus important encore,
le mutex n'est pas déverrouillé. Si l'
l'exclusion mutuelle de l'objet n'a pas
propriété, puis, indépendamment de ce qu'il
est appelé, il n'est pas un mutex.

Leur synchronisation de la sémantique sont très différents:

• mutex permettre de sérialisation de l'accès à une ressource donnée, c'est à dire plusieurs threads attendre un verrou, un à la fois et comme dit précédemment, le fil possède le verrou jusqu'à ce qu'il se fait: seulement ce thread particulier peut le déverrouiller.
• un sémaphore binaire est un compteur avec la valeur 0 et 1: une tâche de blocage jusqu'à tout tâche ne un sem_post. Le sémaphore annonce qu'une ressource est disponible, et il fournit le mécanisme d'attendre jusqu'à ce qu'il est signalé comme étant disponible.

En tant que tel, on peut voir un mutex comme un pion passé de la tâche pour les tâches et le sémaphore de la circulation aux feux rouges (il signaux quelqu'un qu'elle peut procéder).

À un niveau théorique, ils ne sont pas différents du point de vue sémantique. Vous pouvez mettre en œuvre un mutex à l'aide de sémaphores ou vice versa (voir ici pour un exemple). Dans la pratique, la mise en œuvre est différente et qu'ils offrent des services légèrement différents.

La pratique, la différence (en termes de système de services autour de la mer), c'est que la mise en œuvre d'un mutex est destiné à être un plus léger synchronisation. Dans oracle-dire, les mutex sont connus comme loquets et les sémaphores sont connus comme attend.

Au niveau le plus bas, ils utilisent un certain type de atomique tester et régler mécanisme. Ce lit à la valeur actuelle d'un emplacement de mémoire, calcule une sorte de condition, et écrit une valeur à cet endroit, en une seule instruction que ne peut pas être interrompu. Cela signifie que vous pouvez acquérir un mutex et de test pour voir si quelqu'un d'autre qu'il avait avant.

Typique d'un mutex mise en œuvre est un processus ou un thread exécutant le test-and-set d'instructions et d'évaluer si rien d'autre n'avait mis le mutex. Un point clé ici est qu'il n'y a pas d'interaction avec le planificateur, nous n'avons aucune idée (et ne se soucient pas) qui a mis le verrou. Ensuite, soit nous donner notre tranche de temps et essayez à nouveau lorsque la tâche est re-programmée ou exécuter un spin-lock. Un verrou de rotation est un algorithme de type:

Count down from 5000:
     i. Execute the test-and-set instruction
    ii. If the mutex is clear, we have acquired it in the previous instruction 
        so we can exit the loop
   iii. When we get to zero, give up our time slice.

Lorsque nous avons fini de l'exécution de nos protégés code (connu sous le nom section critique) que nous venons de définir le mutex de la valeur à zéro ou ce que signifie " clair.' Si plusieurs tâches sont de tenter d'acquérir le mutex ils la tâche suivante qui se trouve être prévue après le mutex est sorti aurez accès à la ressource. En règle générale, vous utilisez les mutex pour le contrôle d'un synchronisée de ressources où l'accès exclusif n'est nécessaire que pour de très courtes périodes de temps, normalement à faire une mise à jour d'une structure de données partagées.

Un sémaphore est un synchronisée structure de données (généralement à l'aide d'un mutex) qui a un comte et un système d'appel des wrappers qui interagissent avec le planificateur dans un peu plus de profondeur que le mutex bibliothèques. Les sémaphores sont incrémenté et décrémenté et utilisé pour bloc tâches jusqu'à ce que quelque chose d'autre est prêt. Voir Producteur/Consommateur Problème pour un exemple simple de cette. Les sémaphores sont initialisées à la valeur d'un sémaphore binaire est un cas particulier où le sémaphore est initialisé à 1. L'affichage d'un sémaphore a pour effet de réveiller un processus d'attente.

Une base sémaphore algorithme ressemble:

(somewhere in the program startup)
Initialise the semaphore to its start-up value.

Acquiring a semaphore
   i. (synchronised) Attempt to decrement the semaphore value
  ii. If the value would be less than zero, put the task on the tail of the list of tasks waiting on the semaphore and give up the time slice.

Posting a semaphore
   i. (synchronised) Increment the semaphore value
  ii. If the value is greater or equal to the amount requested in the post at the front of the queue, take that task off the queue and make it runnable.  
 iii. Repeat (ii) for all tasks until the posted value is exhausted or there are no more tasks waiting.

Dans le cas d'un sémaphore binaire la principale différence pratique entre les deux est la nature du système de services entourant la structure de données.

EDIT: Comme evan a relevé à juste titre, spinlocks va ralentir une machine monoprocesseur. Vous devez utiliser uniquement un spinlock sur un multi-processeur boîte, car sur un processeur unique, le processus qui détient le mutex sera jamais remis à zéro pendant une autre tâche est en cours d'exécution. Spinlocks ne sont utiles que sur multi-architectures de processeur.

Mutex: Supposons que nous avons de la section critique thread T1 qui veut accéder, puis il suit les étapes ci-dessous.
T1:

1. De verrouillage
2. Utilisation De La Section Critique
3. Déverrouiller

Sémaphore binaire: Il travaille en se fondant sur la signalisation d'attente et de signalisation.
attendre(s) diminution de la valeur "s" par un généralement de valeur "s" est l'initialiser avec la valeur "1",
signal(s) augmente la valeur "s" par un. si "s" a la valeur 1 signifie que personne n'est à l'aide de la section critique, quand la valeur est à 0 signifie que la section critique est en cours d'utilisation.
supposons que le thread T2 est à l'aide de la section critique, alors il suit les étapes ci-dessous.
T2 :

1. attendre(s)//d'abord de valeur est l'un après l'appel de l'attendre de la valeur a diminué de un je.e 0
2. Utilisation de la section critique
3. signal(s) //maintenant, la valeur est augmentée et il devient 1

Principale différence entre les Mutex et sémaphore Binaire est en Mutext si le fil de verrouillage de la section critique, alors qu'il a à débloquer section critique, aucun autre thread ne peut le déverrouiller, mais en cas de sémaphore Binaire si un thread serrures section critique à l'aide d'attente(s) en fonction de la valeur de s deviennent des "0" et personne ne peut y accéder jusqu'à ce que la valeur de "s" devenir 1 mais supposons qu'un autre thread appelle signal(s), puis la valeur de "s" devenir 1 et il permet à d'autres de la fonction pour utiliser la section critique.
donc en Binaire sémaphore thread n'a pas la propriété.

Vous évidemment utiliser un mutex pour verrouiller les données dans un thread arriver accessible par un autre thread en même temps. Supposons que vous avez juste appelé lock() et dans le processus d'accès aux données. Cela signifie que vous ne vous attendez à aucune autre thread (ou une autre instance de la même thread-code) permettant d'accéder aux mêmes données verrouillé par la même mutex. C'est, si c'est le même thread-code obtenir de l'exécution sur un thread différent de l'instance, les hits de la serrure, puis la lock() devrait bloquer le flux de contrôle là. Cela s'applique à un thread qui utilise un thread différent-code, qui est également accès aux mêmes informations et qui est également verrouillé par la même mutex. Dans ce cas, vous êtes encore dans le processus d'accès aux données et vous pouvez prendre, par exemple, un autre de 15 secondes pour atteindre le mutex de déverrouillage (de sorte que l'autre thread est bloqué dans mutex lock permettrait de débloquer et permettre le contrôle de l'accès aux données). Avez-vous à tout prix permettre à encore un autre thread juste déverrouiller le même mutex, et à son tour, permettre le fil qui est déjà en attente (de blocage) dans le mutex lock pour débloquer et d'accéder aux données? J'espère que vous avez ce que je veux dire ici?
Conformément à l'accord de définition universelle!,

• avec “mutex” cela ne se peut. Aucun autre thread ne peut déverrouiller la serrure
  dans votre fil
• avec “binaire-sémaphore” cela peut arriver. Aucun autre thread ne peut déverrouiller
  la serrure dans votre fil

Donc, si vous êtes très particulier au sujet de l'utilisation binaires-sémaphore au lieu de mutex, alors vous devriez être très prudent dans la “portée” de la verrouille et déverrouille. Je veux dire que tous les flux de contrôle qui frappe chaque serrure a frappé un appel de déverrouillage, aussi il ne devrait pas y avoir “d'abord déverrouiller”, il devrait plutôt être toujours “première écluse”.

Mythe:

Couple de l'article dit que "binaire sémaphore mutex et sont même" ou "Sémaphore avec la valeur 1 est mutex" mais la différence fondamentale est de Mutex ne peut être libéré que par le thread qui l'avaient acquise, alors que vous pouvez le signal sémaphore à partir de n'importe quel autre thread

Points Clés:

•Un thread ne peut acquérir plus d'une serrure (Mutex).

•Un mutex peut être verrouillé plus d'une fois que si son récursive de mutex, ici, de verrouillage et de déverrouillage pour le mutex doit être la même

•Si un thread qui avait déjà verrouillé un mutex, tente de verrouiller le mutex à nouveau, il va entrer dans la liste d'attente du mutex, qui résultats dans l'impasse.

•Binaire sémaphore mutex et sont similaires mais pas identiques.

•Mutex est coûteuse en raison de la protection des protocoles associés.

•Objectif principal de mutex est d'atteindre atomique de l'accès ou de verrou sur la ressource

Mutex travail sur le blocage de la région critique, Mais Sémaphore de travail sur le comte.

http://www.geeksforgeeks.org/archives/9102 décrit dans les détails.

Mutex est mécanisme de verrouillage utilisé pour synchroniser l'accès à une ressource.
Semaphore est mécanisme de signalisation.

À de programmeur si il/elle veut utiliser un sémaphore binaire à la place de mutex.

Outre le fait que les mutex ont un propriétaire, les deux objets peuvent être optimisés pour différents usages. Les mutex sont conçus pour être tenu que pour un court laps de temps; la violation cela peut entraîner de mauvaises performances et injuste de la planification. Par exemple, un thread en cours d'exécution peuvent être autorisés à acquérir un mutex, même si un autre thread est déjà bloqué sur elle. Les sémaphores peuvent fournir plus d'équité, ou de l'équité peut être forcé à l'aide de plusieurs variables de condition.

Le concept était clair pour moi après plus de ci-dessus affiche. Mais il y avait une certaine persistance des questions. Alors, j'ai écrit ce petit morceau de code.

Lorsque nous essayons de donner un sémaphore sans le prendre, il va à travers. Mais, lorsque vous essayez de donner un mutex sans le prendre, il échoue. J'ai testé cela sur une plate-forme Windows. Activer USE_MUTEX pour exécuter le même code à l'aide d'un MUTEX.

#include <stdio.h>
#include <windows.h>
#define xUSE_MUTEX 1
#define MAX_SEM_COUNT 1

DWORD WINAPI Thread_no_1( LPVOID lpParam );
DWORD WINAPI Thread_no_2( LPVOID lpParam );

HANDLE Handle_Of_Thread_1 = 0;
HANDLE Handle_Of_Thread_2 = 0;
int Data_Of_Thread_1 = 1;
int Data_Of_Thread_2 = 2;
HANDLE ghMutex = NULL;
HANDLE ghSemaphore = NULL;


int main(void)
{

#ifdef USE_MUTEX
    ghMutex = CreateMutex( NULL, FALSE, NULL);
    if (ghMutex  == NULL) 
    {
        printf("CreateMutex error: %d\n", GetLastError());
        return 1;
    }
#else
    //Create a semaphore with initial and max counts of MAX_SEM_COUNT
    ghSemaphore = CreateSemaphore(NULL,MAX_SEM_COUNT,MAX_SEM_COUNT,NULL);
    if (ghSemaphore == NULL) 
    {
        printf("CreateSemaphore error: %d\n", GetLastError());
        return 1;
    }
#endif
    //Create thread 1.
    Handle_Of_Thread_1 = CreateThread( NULL, 0,Thread_no_1, &Data_Of_Thread_1, 0, NULL);  
    if ( Handle_Of_Thread_1 == NULL)
    {
        printf("Create first thread problem \n");
        return 1;
    }

    /* sleep for 5 seconds **/
    Sleep(5 * 1000);

    /*Create thread 2 */
    Handle_Of_Thread_2 = CreateThread( NULL, 0,Thread_no_2, &Data_Of_Thread_2, 0, NULL);  
    if ( Handle_Of_Thread_2 == NULL)
    {
        printf("Create second thread problem \n");
        return 1;
    }

    //Sleep for 20 seconds
    Sleep(20 * 1000);

    printf("Out of the program \n");
    return 0;
}


int my_critical_section_code(HANDLE thread_handle)
{

#ifdef USE_MUTEX
    if(thread_handle == Handle_Of_Thread_1)
    {
        /* get the lock */
        WaitForSingleObject(ghMutex, INFINITE);
        printf("Thread 1 holding the mutex \n");
    }
#else
    /* get the semaphore */
    if(thread_handle == Handle_Of_Thread_1)
    {
        WaitForSingleObject(ghSemaphore, INFINITE);
        printf("Thread 1 holding semaphore \n");
    }
#endif

    if(thread_handle == Handle_Of_Thread_1)
    {
        /* sleep for 10 seconds */
        Sleep(10 * 1000);
#ifdef USE_MUTEX
        printf("Thread 1 about to release mutex \n");
#else
        printf("Thread 1 about to release semaphore \n");
#endif
    }
    else
    {
        /* sleep for 3 secconds */
        Sleep(3 * 1000);
    }

#ifdef USE_MUTEX
    /* release the lock*/
    if(!ReleaseMutex(ghMutex))
    {
        printf("Release Mutex error in thread %d: error # %d\n", (thread_handle == Handle_Of_Thread_1 ? 1:2),GetLastError());
    }
#else
    if (!ReleaseSemaphore(ghSemaphore,1,NULL) )      
    {
        printf("ReleaseSemaphore error in thread %d: error # %d\n",(thread_handle == Handle_Of_Thread_1 ? 1:2), GetLastError());
    }
#endif

    return 0;
}

DWORD WINAPI Thread_no_1( LPVOID lpParam ) 
{ 
    my_critical_section_code(Handle_Of_Thread_1);
    return 0;
}


DWORD WINAPI Thread_no_2( LPVOID lpParam ) 
{
    my_critical_section_code(Handle_Of_Thread_2);
    return 0;
}

Le fait même que le sémaphore permet de signal "c'est fait à l'aide d'une ressource", même si elle n'a jamais possédé de la ressource, me fait penser il y a un très couplage lâche entre la possession et de la signalisation dans le cas de sémaphores.

Mutex est utilisé pour protéger le sensible, le code et les données, sémaphore est utilisé pour la synchronisation.Vous pouvez également avoir un usage pratique à protéger le sensible code, mais il pourrait y avoir un risque que la libération de la protection par l'autre thread par opération V. Donc La principale différence entre les bi-sémaphore mutex et est la propriété.Par exemple, toilettes , Mutex est comme ça, on peut entrer dans les toilettes et verrouiller la porte, personne ne peut entrer jusqu'à l'homme de sortir, bi-sémaphore est comme ça on peut entrer dans les toilettes et verrouiller la porte, mais quelqu'un d'autre pourrait entrer en demandant à l'administrateur pour ouvrir la porte, c'est ridicule.

Mutex ont la propriété, à la différence de sémaphores. Bien que n'importe quel thread, dans le cadre d'un mutex, peut obtenir une déverrouillé mutex et de verrouiller l'accès à la même section critique de code,seulement le thread qui a verrouillé un mutex devrait déverrouiller.

Mutex et sémaphore binaire sont tous les deux de la même utilisation, mais en réalité, ils sont différents.

En cas de mutex, seul le thread qui ont verrouillé, il peut le déverrouiller. Si un autre thread pour le verrouiller, il faudra patienter.

En cas de semaphone, ce n'est pas le cas. Sémaphore n'est pas attaché avec un fil ID.

Mutex

Les mutex sont généralement utilisés pour serialise l'accès à une section de ré-entrant le code qui ne peuvent pas être exécutées simultanément par plusieurs threads. Un objet mutex permet uniquement d'un fil dans une section contrôlée, forçant les autres threads qui tentent d'accéder à cette section d'attendre jusqu'à ce que le premier thread a quitté à partir de cette section.Utilisation correcte d'un mutex est de protéger une ressource partagée peut avoir un dangereux effet secondaire involontaire. Deux RTOS tâches qui opèrent à différentes priorités et de coordonner via un mutex, de créer la possibilité pour inversion de priorité. Mutex travaille dans de l'espace utilisateur.

Sémaphore

Sémaphore est un mécanisme de signalisation. Sémaphore limite le nombre d'utilisateurs simultanés d'une ressource partagée jusqu'à un nombre maximum. Les Threads peuvent demander l'accès à la ressource (décrémenter le sémaphore) et peut être le signal qu'ils ont fini d'utiliser la ressource (l'incrémentation du sémaphore). Il permet à nombre de thread pour accéder aux ressources partagées.L'utilisation correcte d'un sémaphore est pour la signalisation d'une tâche à une autre.les sémaphores peut également être utilisé pour le signal d'une routine de service d'interruption (ISR) à une tâche. La signalisation sémaphore est un non-bloquant RTOS comportement, et donc ISR coffre-fort. Parce que cette technique élimine le risque d'erreur de besoin de désactiver les interruptions au niveau de la tâche.Cela fonctionne dans l'espace noyau.