private InstrumentInfo[] instrumentInfos = new InstrumentInfo[Constants.MAX_INSTRUMENTS_NUMBER_IN_SYSTEM];

public void SetInstrumentInfo(Instrument instrument, InstrumentInfo info)
{
    if (instrument == null || info == null)
    {
        return;
    }
    instrumentInfos[instrument.Id] = info;  // need to make it visible to other threads!
}

public InstrumentInfo GetInstrumentInfo(Instrument instrument)
{
    return instrumentInfos[instrument.Id];  // need to obtain fresh value!
}

SetInstrumentInfo 和 GetInstrumentInfo 从不同线程调用。 InstrumentInfo 是不可变类。 调用 GetInstrumentInfo 时，我是否保证拥有最新的副本？恐怕我会收到“缓存”副本。我应该添加某种同步吗？

将 instrumentInfos 声明为 volatile 无济于事，因为我需要将数组项声明为 volatile，而不是数组本身。

我的代码有问题吗？如果有，如何解决？

UPD1:

我需要我的代码在现实生活中工作而不是符合所有规范!因此，如果我的代码在现实生活中有效，但在某些环境下的某些计算机上“理论上”无法正常工作 - 没关系!

• 我需要我的代码在 Windows 下使用最新的 .NET Framework 在现代 X64 服务器(目前有 2 个处理器 HP DL360p Gen8)上运行。
• 我不需要在陌生的计算机或 Mono 或其他任何东西下工作我的代码
• 我不想引入延迟，因为这是 HFT 软件。因此，“微软的实现使用强大的内存模型进行写入。这意味着写入被视为 volatile ”，我可能不需要添加额外的 Thread.MemoryBarrier ，它只会增加延迟.我认为我们可以相信微软将在未来的版本中继续使用“强内存模型”。至少微软不太可能改变内存模型。所以我们假设它不会。

UPD2:

最近的建议是使用 Thread.MemoryBarrier();。现在我不明白我必须将它插入的确切位置才能使我的程序在标准配置(x64、Windows、Microsoft .NET 4.0)上运行。请记住，我不想插入“只是为了能够在 IA64 或 .NET 10.0 上启动您的程序”的行。速度对我来说比便携性更重要。然而，如何更新我的代码以便它可以在任何计算机上运行也很有趣。

UPD3

.NET 4.5 解决方案:

    public void SetInstrumentInfo(Instrument instrument, InstrumentInfo info)
    {
        if (instrument == null || info == null)
        {
            return;
        }
        Volatile.Write(ref instrumentInfos[instrument.Id], info);
    }

    public InstrumentInfo GetInstrumentInfo(Instrument instrument)
    {
        InstrumentInfo result = Volatile.Read(ref instrumentInfos[instrument.Id]);
        return result;
    }

最佳答案

这个问题的答案又长又复杂，但我会尝试将其提炼成一些可行的建议。

<强>1。简单的解决方案:仅在锁定下访问 instrumentInfos

避免多线程程序中不可预测性的最简单方法是始终使用锁来保护共享状态。

根据您的意见，您似乎认为此解决方案过于昂贵。您可能想要仔细检查该假设，但如果情况确实如此，那么让我们看看剩余的选项。

<强>2。进阶方案:Thread.MemoryBarrier

或者，您可以使用 Thread.MemoryBarrier:

private InstrumentInfo[] instrumentInfos = new InstrumentInfo[Constants.MAX_INSTRUMENTS_NUMBER_IN_SYSTEM]; 

public void SetInstrumentInfo(Instrument instrument, InstrumentInfo info) 
{ 
    if (instrument == null || info == null) 
    { 
        return; 
    } 

    Thread.MemoryBarrier(); // Prevents an earlier write from getting reordered with the write below

    instrumentInfos[instrument.Id] = info;  // need to make it visible to other threads! 
} 

public InstrumentInfo GetInstrumentInfo(Instrument instrument) 
{ 
    InstrumentInfo info = instrumentInfos[instrument.Id];  // need to obtain fresh value! 
    Thread.MemoryBarrier(); // Prevents a later read from getting reordered with the read above
    return info;
}

在写入之前和读取之后使用 Thread.MemoryBarrier 可以防止潜在的麻烦。第一个内存屏障防止写线程用将对象发布到数组中的写操作对初始化对象字段的写操作重新排序，第二个内存屏障防止读线程对从数组接收对象的读操作重新排序。随后读取该对象的字段。

作为旁注，.NET 4 还公开了使用 Thread.MemoryBarrier 的 Thread.VolatileRead 和 Thread.VolatileWrite，如上所示。但是，对于 System.Object 以外的引用类型，没有 Thread.VolatileRead 和 Thread.VolatileWrite 的重载。

<强>3。高级解决方案 (.NET 4.5):Volatile.Read 和 Volatile.Write

.NET 4.5 公开了比完整内存屏障更有效的 Volatile.Read 和 Volatile.Write 方法。如果您的目标是 .NET 4，此选项将无济于事。

<强>4。 “错误但会发生”解决方案

你永远不应该依赖我将要说的话。但是……您不太可能重现原始代码中存在的问题。

事实上，在 .NET 4 中的 X64 上，如果您能重现它，我会感到非常惊讶。 X86-X64 提供了相当强大的内存重新排序保证，因此这些类型的 Release模式恰好可以正常工作。 .NET 4 C# 编译器和 .NET 4 CLR JIT 编译器也避免了会破坏您的模式的优化。因此，允许重新排序内存操作的三个组件都不会碰巧这样做。

就是说，有一些(有点模糊的) Release模式变体实际上不适用于 X64 中的 .NET 4。因此，即使您认为代码永远不需要在 .NET 4 X64 以外的任何体系结构上运行，如果您使用其中一种正确的方法，您的代码将更易于维护，即使该问题目前无法在您的服务器上重现.

关于c# - 如何保证 Array 中 "reference type"项目的更新对其他线程可见？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11954589/