Ho letto di recente sulle barriere della memoria e sul problema del riordino e ora ho una certa confusione a riguardo.Memory Barrier per lock statement
Si consideri il seguente scenario:
private object _object1 = null;
private object _object2 = null;
private bool _usingObject1 = false;
private object MyObject
{
get
{
if (_usingObject1)
{
return _object1;
}
else
{
return _object2;
}
}
set
{
if (_usingObject1)
{
_object1 = value;
}
else
{
_object2 = value;
}
}
}
private void Update()
{
_usingMethod1 = true;
SomeProperty = FooMethod();
//..
_usingMethod1 = false;
}
A
Update
metodo; è l'istruzione_usingMethod1 = true
eseguita sempre prima di ottenere o impostare la proprietà? o a causa di un problema di riordino, non possiamo garantirlo?dovremmo usare
volatile
comeprivate volatile bool _usingMethod1 = false;
Se usiamo
lock;
possiamo garantire quindi ogni affermazione all'interno della serratura saranno eseguiti in modo simile:private void FooMethod() { object locker = new object(); lock (locker) { x = 1; y = a; i++; } }
Grazie per l'informazione, mi aiuta davvero a capire meglio il concetto. Quello che mi serve per essere sicuro è che l'istruzione "_usingMethod1 = true" verrà eseguita sempre prima dell'istruzione next SomeProperty = FooMethod(); Nel multithread senario come realizzarlo? è di: _usingMethod1 = true; Thread.MemoryBarrier(); SomeProperty = FooMethod(); o blocca per recinti pieni quindi non riordinare: lock (locker) {_usingMethod1 = true; } SomeProperty = FooMethod(); o forse semplicemente rendendo _usingMethod1 una variabile volatile. Grazie per l'aiuto. –
Vorrei avvolgere l'intero contenuto del metodo di aggiornamento in un blocco. Oltre alle barriere della memoria, garantisce anche l'atomicità, che è altrettanto importante. Inoltre, questi idiomi lock-free (via volatile, Thread.MemoryBarrier, ecc.) Sono incredibilmente difficili da ottenere. –