Che tipo di operazione 'volatili' è necessario in ricontrollato blocco in .NET

Question

ho preso il codice di DCL dal libro di Joe Duffy 'Programmazione concorrente sulle finestre'

class LazyInit<T> where T : class 
{ 
private volatile T m_value; 
private object m_sync = new object(); 
private Func<T> m_factory; 
public LazyInit(Func<T> factory) { m_factory = factory; } 
public T value 
{ 
    get 
    { 
    if (m_value == null) 
    { 
     lock (m_sync) 
     { 
     if (m_value == null) 
     { 
      m_value = m_factory(); 
     } 
     } 
    } 
    return m_value; 
    } 
} 
} 

si dice marcatura m_value volatili può prevenire scrive riordinamenti che porteranno ad altri thread ottenendo 'oggetto non nullo con campi non inizializzati'. Se il problema si verifica solo perché le possibili scritture possono essere riordinate, posso semplicemente usare "Volatile Write" invece di contrassegnare il file volatile, come di seguito? (Questo codice è un po 'imbarazzante per la dimostrazione, voglio solo per assicurarsi che, se siamo in grado di utilizzare solo scrittura volatili invece)

class LazyInit<T> where T : class 
{ 
private object m_value; 
private object m_sync = new object(); 
private Func<T> m_factory; 
public LazyInit(Func<T> factory) { m_factory = factory; } 
public T value 
{ 
    get 
    { 
    if (m_value == null) 
    { 
     lock (m_sync) 
     { 
     if (m_value == null) 
     { 
      Thread.VolatileWrite(ref m_value, m_factory()); 
     } 
     } 
    } 
    return (T)m_value; 
    } 
} 
} 

Una questione correlata è la versione Interlocked dal libro

class LazylnitRelaxedRef<T> where T : class 
{ 
private volatile T m_value; 
private Func<T> m_factory; 
public LazylnitRelaxedRef(Func<T> factory) { m_factory = factory; } 
public T Value 
{ 
    get 
    { 
    if (m_value == null) 
     Interlocked.CompareExchange(ref m_value, m_factory(), null); 
    return m_value; 
    } 
} 
} 

Dal le specifiche ECMA-CLI "L'operazione interbloccata esegue operazioni di acquisizione/rilascio implicite", abbiamo ancora bisogno di volatilità in questo caso?

Answer 1

In primo luogo, fare casino con volatile è davvero difficile, quindi non perdetevelo! Ma, here è una risposta molto vicino alla tua domanda, e here è un articolo che penso che tutti dovrebbero leggere prima di utilizzare la parola chiave volatile, e sicuramente prima di iniziare a usare VolatileRead, VolatileWrite e MemoryBarrier.

La risposta nel primo link è: no, non è necessario utilizzare volatili, basta utilizzare System.Threading.Thread.MemoryBarrier() destra prima di assegnare il nuovo valore. Questo perché il release_fence implicito quando si utilizza la parola chiave volatile si assicura che sia terminato di scrivere nella memoria principale e che nessuna operazione di lettura/scrittura possa essere eseguita fino al termine.

Quindi, cosa fa Thread.VolatileWrite() e ha le stesse funzioni che otteniamo dalla parola chiave "volatile"? Bene, ecco il codice completo da questa funzione:

public static void VolatileWrite (ref int address, int value) 
{ 
    MemoryBarrier(); address = value; 
} 

Sì, chiama MemoryBarrier destra prima assegna il vostro valore, il che è sufficiente!