Mecanismo de sincronización de variables de bloqueo

Requisitos previos: sincronización de procesos
Una variable de bloqueo proporciona el mecanismo de sincronización más simple para los procesos. Algunos puntos dignos de mención con respecto a las variables de bloqueo son: 

1. Es un mecanismo de software implementado en modo usuario, es decir, no requiere soporte del Sistema Operativo.
2. Es una solución de espera ocupada (mantiene la CPU ocupada incluso cuando técnicamente está esperando).
3. Se puede utilizar para más de dos procesos.

Cuando Lock = 0 implica que la sección crítica está vacante (valor inicial) y Lock = 1 implica que la sección crítica está ocupada.
El pseudocódigo se parece a esto: 

Entry section - while(lock != 0);
                Lock = 1;
//critical section
Exit section - Lock = 0;

En el siguiente fragmento de código se puede ver un enfoque más formal del método de bloqueo de variables para la sincronización de procesos:

char buffer[SIZE];
int count = 0,
    start = 0,
    end = 0;
struct lock l;
 
// initialize lock variable
lock_init(&l);
 
void put(char c)
{
 
    // entry section
    lock_acquire(&l);
 
    // critical section begins
    while (count == SIZE) {
 
        lock_release(&l);
        lock_acquire(&l);
    }
 
    count++;
    buffer[start] = c;
    start++;
 
    if (start == SIZE) {
 
        start = 0;
    }
 
    // critical section ends
    // exit section
    lock_release(&l);
}
 
char get()
{
 
    char c;
 
    // entry section
    lock_acquire(&l);
 
    // critical section begins
    while (count == 0) {
 
        lock_release(&l);
        lock_acquire(&l);
    }
 
    count--;
    c = buffer[end];
    end++;
 
    if (end == SIZE) {
 
        end = 0;
    }
 
    // critical section ends
    // exit section
    lock_release(&l);
 
    return c;
}

Aquí podemos ver una implementación clásica del problema del lector-escritor. El búfer aquí es la memoria compartida y muchos procesos intentan leer o escribir un carácter en él. Para evitar cualquier ambigüedad de los datos, restringimos el acceso simultáneo mediante el uso de una variable de bloqueo. También hemos aplicado una restricción en el número de lectores/escritores que pueden tener acceso.
Ahora, cada mecanismo de sincronización se juzga sobre la base de tres parámetros principales: 

1. Exclusión mutua.
2. Progreso.
3. Espera limitada.

De los cuales la exclusión mutua es el más importante de todos los parámetros. La variable de bloqueo no proporciona exclusión mutua en algunos casos. Este hecho se puede verificar mejor escribiendo su pseudocódigo en forma de código de lenguaje ensamblador como se indica a continuación.

1. Load Lock, R0 ; (Store the value of Lock in Register R0.)
2. CMP R0, #0 ; (Compare the value of register R0 with 0.)
3. JNZ Step 1 ; (Jump to step 1 if value of R0 is not 0.)
4. Store #1, Lock ; (Set new value of Lock as 1.)
Enter critical section
5. Store #0, Lock ; (Set the value of lock as 0 again.)

Ahora supongamos que los procesos P1 y P2 están compitiendo por la Sección Crítica y su secuencia de ejecución es la siguiente (valor inicial de Lock = 0) –

1. P1 ejecuta la declaración 1 y se adelanta.
2. P2 ejecuta la declaración 1, 2, 3, 4 e ingresa a la Sección crítica y se adelanta.
3. P1 ejecuta la instrucción 2, 3, 4 y también ingresa a la Sección Crítica.

Aquí, inicialmente, el R0 del proceso P1 almacena el valor de bloqueo como 0 pero no actualiza el valor de bloqueo como 1. Entonces, cuando P2 se ejecuta, también encuentra el valor de BLOQUEO como 0 e ingresa a la Sección crítica configurando el valor de BLOQUEO como 1. Pero surge el verdadero problema cuando P1 se ejecuta nuevamente, no verifica el valor actualizado de Lock. Solo revisa el valor anterior guardado en R0 que era 0 y entra a sección crítica.
Esta es solo una posible secuencia de ejecución entre muchas otras. Algunos incluso pueden proporcionar exclusión mutua, pero no podemos detenernos en eso. Según la ley de murphy “ Todo lo que puede salir mal, saldrá mal“. Entonces, como todas las cosas fáciles, el método de sincronización variable de bloqueo viene con una buena cantidad de deméritos, pero es un buen punto de partida para que desarrollemos mejores algoritmos de sincronización para solucionar los problemas que enfrentamos aquí. 
Este artículo es una contribución de Siddhant Bajaj 2 . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.