¿Las variables de condición todavía necesitan un mutex si está cambiando el valor verificado atómicamente?

Question

Esta es la forma típica de usar una variable condición:

// The reader(s) 
lock(some_mutex); 
if(protected_by_mutex_var != desired_value) 
    some_condition.wait(some_mutex); 
unlock(some_mutex); 

// The writer 
lock(some_mutex); 
protected_by_mutex_var = desired_value; 
unlock(some_mutex); 
some_condition.notify_all(); 

Pero si protected_by_mutex_var se establece atómicamente por ejemplo, una instrucción de comparación y de intercambio, sirve el mutex cualquier propósito (excepto los de pthreads y otros Las API requieren que pases un mutex)? ¿Está protegiendo el estado utilizado para implementar la condición? Si no es así, ¿es seguro después de hacer esto ?:

// The writer 
atomic_set(protected_by_mutex_var, desired_value); 
some_condition.notify_all(); 

Con el escritor nunca directamente interactuar con mutex del lector? Tenga en cuenta que el nombre 'protected_by_mutex_var' ya no es realmente apropiado (ya no está protegido por mutex). Si es así, ¿es necesario que otros lectores usen el mismo mutex?

Answer 1

imaginar el siguiente escenario:

| Thread 1           | Thread 2           | 
| if(protected_by_mutex_var != desired_value) -> true |             | 
|              | atomic_set(protected_by_mutex_var, desired_value); | 
|              | some_condition.notify_all();      | 
| some_condition.wait(some_mutex);     |             | 

Esta situación ve Tema 1 en espera de un notifique que puede no llegar nunca. Debido a que las declaraciones que actúan sobre la condición no son parte de la variable lectura/conjunto atómico, esto presenta una condición de carrera.

Usando el mutex hace efectivamente estas acciones inseparables (suponiendo que todos los accesos a la variable se comporte adecuadamente y bloquear el mutex.)