Non variabili di condizione ancora bisogno di un mutex se si sta cambiando il valore controllato atomico?

Question

Ecco il tipico modo di utilizzare una variabile di condizione:

// 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();

Ma se protected_by_mutex_var è impostato in modo atomico per esempio, un'istruzione di confronto-e-swap, fa il mutex servire qualsiasi scopo (diverso da quello pthreads e altre API richiedono di passare in un mutex)? E 'protegge stato utilizzato per implementare la condizione? In caso contrario, è sicuro, allora per fare questo:?

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

Con lo scrittore mai direttamente interagire con mutex del lettore? Si noti che il nome di 'protected_by_mutex_var' non è più davvero appropriato (non è protetto mutex più). Se è così, è anche necessario che diversi lettori usano lo stesso mutex?

Answer 1

Immaginate il seguente scenario:

| 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);                    |                                                    |

Questa situazione vede Thread 1 in attesa di un notificare che non può mai venire. Poiché le dichiarazioni che agiscono sulla condizione non fanno parte della lettura variabile / set atomica, questo presenta una condizione di competizione.

Utilizzando il mutex rende efficacemente queste azioni inseparabili (supponendo che tutti gli accessi alla variabile comportarsi correttamente e bloccare il mutex.)