O código a seguir deve armazenar em cache a última leitura. oLastValueCache é um cache que pode ser acessado por vários threads (é por isso que eu uso a memória compartilhada). Não há problema em eu ter condições de corrida, mas quero que outros tópicos vejam as alteraçõesLastValueCache.

class Repository
{
    public Item LastValueCache
    {
        get
        {
            Thread.MemoryBarrier();
            SomeType result = field;
            Thread.MemoryBarrier();
            return result;
        }
        set
        {
            Thread.MemoryBarrier();
            field = value;
            Thread.MemoryBarrier();
        }
    }

    public void Save(Item item)
    {
        SaveToDatabase(item);
        Item cached = LastValueCache;
        if (cached == null || item.Stamp > cached.Stamp)
        {
            LastValueCache = item;
        }
    }

    public void Remove(Timestamp stamp)
    {
        RemoveFromDatabase(item);
        Item cached = LastValueCache;
        if (cached != null && cached.Stamp == item.Stamp)
        {
            LastValueCache = null;
        }
    }

    public Item Get(Timestamp stamp)
    {
        Item cached = LastValueCache;
        if (cached != null && cached.Stamp == stamp)
        {
            return cached;
        }

        return GetFromDatabase(stamp);
    }
}

oRepository O objeto é usado por muitos threads. Não quero usar o bloqueio porque isso afetaria o desempenho, que no meu caso é mais importante que a consistência dos dados. A questão équal o menor mecanismo de sincronização que atenderá às minhas necessidades? Talvezvolatile ou solteiroMemoryBarrier noget eset seria o suficiente?