¿Diferencia entre exclusión mutua y sincronización?

Question

¿Cuál es la diferencia entre los dos anteriores?

Esta pregunta me vino a la mente, porque me encontré con que

1. Monitores y cerraduras proporcionan exclusión mutua

2. semáforos y variables condicionales proporcionar sincronización

Está ¿esta verdad?

también durante la búsqueda me encontré con este article

posibles clarificaciones por favor.

Answer 1

exclusión mutua significa que solo un hilo único debe poder acceder al recurso compartido en cualquier momento dado. Esto evita las condiciones de carrera entre los hilos que adquieren el recurso. Los monitores y las cerraduras proporcionan la funcionalidad para hacerlo.

Sincronización significa que sincroniza/ordena el acceso de múltiples hilos al recurso compartido.
Considere el ejemplo:
Si tiene dos hilos, Thread 1 & Thread 2.
Thread 1 y Thread 2 se ejecutan en paralelo pero antes Thread 1 puede ejecutar decir una declaración A en su secuencia es una necesidad que Thread 2 debe ejecutar una instrucción B en su secuencia. Lo que necesitas aquí es la sincronización. Un semáforo proporciona eso. Pones una espera de espermapoore antes de la declaración A en Thread 1 y la publicas en el semáforo después de la declaración B en Thread 2.
Esto garantiza la sincronización que necesita.

Answer 2

La mejor manera de entender la diferencia es con la ayuda de un ejemplo. A continuación se muestra el programa para resolver el problema del consumidor clásico productor mediante semáforo. Para proporcionar exclusión mutua, generalmente utilizamos un semáforo binario o mutex y para proporcionar sincronización usar contando semáforo

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 
    } 
} 

En el código anterior la variable mutex proporciona la exclusión mutua (permitir sólo un hilo para acceder a la sección crítica), mientras que completa y la variable de vacío se utilizan para synchonization (a aribtrate el acceso de recurso compartido entre varios hilo).