Différence entre exclusion mutuelle et synchronisation?

Quelle est la différence entre les deux?

Cette question est venue à mon esprit parce que je trouve que

  1. Les moniteurs et les verrous de fournir de l'exclusion mutuelle
  2. Les sémaphores et les variables conditionnelles fournir la synchronisation

Est-ce vrai?

Aussi en cherchant j'ai trouvé ce l'article

Des précisions s'il vous plaît.

source d'informationauteur Tanya | 2012-04-11

  1. 19

    Exclusion mutuelle signifie que seul un thread doit être en mesure d'accéder à la ressource partagée à tout moment. Cela évite que les conditions de concurrence entre les threads acquireing la ressource. Les moniteurs et les Serrures de fournir la fonctionnalité de le faire.

    Synchronisation signifie que vous synchronisez/commander l'accès de plusieurs threads à la ressource partagée.

    Prenons l'exemple:

    Si vous avez deux fils, Thread 1 & Thread 2.

    Thread 1 et Thread 2 exécuter en parallèle, mais avant Thread 1 peut exécuter dire une déclaration A dans sa séquence, il est indispensable que Thread 2 doit exécuter une instruction B dans sa séquence. Ce dont vous avez besoin ici est la synchronisation. Un sémaphore prévoit que. Vous mettez un semapohore attendre avant de faire la déclaration A dans Thread 1 et que vous affichez le sémaphore après déclaration B dans Thread 2.

    Cela garantit la synchronisation dont vous avez besoin.

  2. 0

    La meilleure façon de comprendre la différence est avec l'aide d'un exemple.Ci-dessous le programme pour résoudre le classique producteur problème de consommation via semaphore.Pour fournir de l'exclusion mutuelle nous genrally utiliser un sémaphore binaire ou d'un mutex et de fournir la synchronisation nous utiliser le comptage de sémaphore.

    BufferSize = 3;

semaphore mutex = 1;              //used for mutual exclusion
semaphore empty = BufferSize;     //used for synchronization
semaphore full = 0;               //used for synchronization

Producer()
 {
  int widget;

   while (TRUE) {                  //loop forever
     make_new(widget);             //create a new widget to put in the buffer
     down(&empty);                 //decrement the empty semaphore
     down(&mutex);                 //enter critical section
     put_item(widget);             //put widget in buffer
     up(&mutex);                   //leave critical section
     up(&full);                    //increment the full semaphore
   }
 }

Consumer()
{
  int widget;

   while (TRUE) {                  //loop forever
     down(&full);                  //decrement the full semaphore
     down(&mutex);                 //enter critical section
     remove_item(widget);          //take a widget from the buffer
     up(&mutex);                   //leave critical section
     consume_item(widget);         //consume the item
  }
}

    Dans le code ci-dessus le mutex variable permet d'exclusion mutuelle(un seul thread d'accéder à la section critique) alors que le plein et le vide variable sont utilisés pour la synchronisation(pour aribtrate l'accès à des ressources partagées entre les différents thread).