stranezza Volatile

Question

Penso che la maggior parte delle persone sono a conoscenza del problema seguente che avviene quando si costruisce in modalità di rilascio (codice preso dal Threading in C#):

static void Main() 
{ 
    bool complete = false; 

    var t = new Thread (() => 
    { 
    bool toggle = false; 
    while (!complete) toggle = !toggle; 
    }); 

    t.Start(); 
    Thread.Sleep (1000); 

    complete = true; 
    t.Join();  // Blocks indefinitely 
} 

a causa di ottimizzazioni del compilatore cache il valore della complete e impedendo così il bambino thread da mai vedere il valore aggiornato.

Tuttavia, cambiando il codice di sopra di un bit:

class Wrapper 
{ 
    public bool Complete { get; set; } 
} 

class Test 
{ 
    Wrapper wrapper = new Wrapper(); 

    static void Main() 
    { 
     var test = new Test(); 
     var t = new Thread(() => 
     { 
      bool toggle = false; 
      while (!test.wrapper.Complete) toggle = !toggle; 
     }); 

     t.Start(); 
     Thread.Sleep(1000); 

     test.wrapper.Complete = true; 
     t.Join();  // Blocks indefinitely 
    } 
} 

rende il problema andare via (cioè il filo bambino è in grado di uscire dopo 1 secondo) senza l'uso di volatile, recinzioni memoria, o qualsiasi altra meccanismo che introduce una recinzione implicita.

In che modo l'incapsulamento aggiunto dell'indicatore di completamento influenza la sua visibilità tra i thread?

Answer 1

Penso che tu abbia la risposta nella tua domanda:

a causa di ottimizzazioni del compilatore cache il valore della completa e impedendo così il filo bambino da mai vedere il valore aggiornato.

Le ottimizzazioni Compilatore/JIT vengono eseguite ogni volta che è logico/ritenuto sicuro e ragionevole da implementare. Quindi hai trovato casi in cui l'ottimizzazione non viene eseguita nel modo in cui ti aspetti che accada, forse c'è una buona ragione (qualcuno ha rilevato questo schema di utilizzo e l'ottimizzazione dei blocchi) o semplicemente non è stato ottimizzato (molto probabilmente).

Answer 2

Il primo caso è una semplice propagazione di alias su una variabile locale. I compilatori lo fanno in modo abbastanza aggressivo (http://en.m.wikipedia.org/wiki/Aliasing_(computing)) Il secondo caso, anche se sembra lo stesso a causa della sintattica somiglianza delle proprietà con le variabili membro, ha chiamate di metodo (getter/setter) e non può essere semplicemente semplificato.