Leituras de campos voláteis adquirem semântica . Isso significa que é garantido que a memória lida na variável volátil ocorrerá antes que qualquer memória a seguir seja lida. Ele impede o compilador de fazer a reordenação e, se o hardware exigir (CPU com pouca ordem), ele usará uma instrução especial para fazer com que o hardware libere todas as leituras que ocorram após a leitura volátil, mas que foram especulativamente iniciadas mais cedo, ou a CPU pode impedir que eles sejam emitidos no início, impedindo que ocorra carga especulativa entre a emissão da carga adquirida e sua retirada.
Gravações de campos voláteis têm semântica de liberação . Isso significa que é garantido que qualquer gravação de memória na variável volátil seja atrasada até que todas as gravações de memória anteriores sejam visíveis para outros processadores.
Considere o seguinte exemplo:
something.foo = new Thing();
Se foofor uma variável membro de uma classe e outras CPUs tiverem acesso à instância do objeto mencionada por something, elas poderão ver o valor foomudar antes que a memória gravada no Thingconstrutor seja visível globalmente! É isso que significa "memória fracamente ordenada". Isso pode ocorrer mesmo se o compilador tiver todas as lojas no construtor antes da loja foo. Se foofor volatile, o armazenamento footerá semântica de liberação, e o hardware garante que todas as gravações antes da gravação foosejam visíveis para outros processadores antes de permitir que a gravação fooocorra.
Como é possível que as gravações foosejam reordenadas tão mal? Se a retenção da linha de cache fooestiver no cache e as lojas do construtor não tiverem o cache, é possível que o armazenamento seja concluído muito mais cedo do que as gravações no cache.
A (terrível) arquitetura Itanium da Intel tinha pedido pouco de memória. O processador usado no XBox 360 original tinha pouca memória solicitada. Muitos processadores ARM, incluindo o muito popular ARMv7-A, têm pouca memória solicitada.
Os desenvolvedores geralmente não veem essas corridas de dados porque coisas como bloqueios criarão uma barreira total à memória, essencialmente a mesma coisa que adquirir e liberar semântica ao mesmo tempo. Nenhuma carga dentro do bloqueio pode ser executada especulativamente antes que o bloqueio seja adquirido; eles são adiados até que o bloqueio seja adquirido. Nenhum armazenamento pode ser atrasado em uma liberação de bloqueio, a instrução que libera o bloqueio é adiada até que todas as gravações feitas dentro do bloqueio sejam visíveis globalmente.
Um exemplo mais completo é o padrão "Bloqueio verificado duas vezes". O objetivo desse padrão é evitar a necessidade de sempre obter um bloqueio para inicializar com preguiça um objeto.
Snagged da Wikipedia:
public class MySingleton {
private static object myLock = new object();
private static volatile MySingleton mySingleton = null;
private MySingleton() {
}
public static MySingleton GetInstance() {
if (mySingleton == null) { // 1st check
lock (myLock) {
if (mySingleton == null) { // 2nd (double) check
mySingleton = new MySingleton();
// Write-release semantics are implicitly handled by marking
// mySingleton with 'volatile', which inserts the necessary memory
// barriers between the constructor call and the write to mySingleton.
// The barriers created by the lock are not sufficient because
// the object is made visible before the lock is released.
}
}
}
// The barriers created by the lock are not sufficient because not all threads
// will acquire the lock. A fence for read-acquire semantics is needed between
// the test of mySingleton (above) and the use of its contents. This fence
// is automatically inserted because mySingleton is marked as 'volatile'.
return mySingleton;
}
}
Neste exemplo, as lojas no MySingletonconstrutor podem não estar visíveis para outros processadores antes da loja mySingleton. Se isso acontecer, os outros threads que espreitam o mySingleton não adquirem um bloqueio e não capturam necessariamente as gravações no construtor.
volatilenunca impede o armazenamento em cache. O que ele faz é garantir a ordem na qual outros processadores "vêem" gravam. Uma liberação de loja atrasará uma loja até que todas as gravações pendentes sejam concluídas e um ciclo de barramento tenha sido emitido, informando outros processadores para descartar / gravar novamente sua linha de cache, se as linhas relevantes estiverem em cache. Uma aquisição de carga liberará todas as leituras especuladas, garantindo que elas não sejam valores obsoletos do passado.