结构数组的 C# 并发性
本文关键字:并发 数组 结构 | 更新日期: 2023-09-27 18:36:57
给定一个结构数组:
public struct Instrument
{
public double NoS;
public double Last;
}
var a1 = new Instrument[100];
还有一个线程任务池,它正在写入这些元素,其基础是单个元素最多可以由两个线程同时写入,每个线程一个用于双精度字段(有效地按主题进行上游排队)。
以及双精度可以在 64 位上原子写入的知识。(编辑这个错误地说原来是32位)
我需要使用数组中的所有值定期执行计算,我希望它们在计算过程中保持一致。
因此,我可以使用以下命令对阵列进行快照:
var snapshot = a1.Clone();
现在我的问题是关于同步的细节。如果我使成员易失性,我认为这根本不会对克隆有所帮助,因为读/写获取/释放不在数组级别。
现在我可以有一个数组锁,但这会增加对将数据写入数组的最频繁过程的大量争用。所以不理想。
或者,我可以有一个每行锁定,但这将是一个真正的痛苦,因为它们都需要在克隆之前获得,同时我已经备份了所有写入。
现在,如果快照没有最新的值,如果是微秒等,这并不重要,所以我想我可能会摆脱没有锁定。我唯一担心的是是否存在持续一段时间没有缓存写回的情况。这是我应该担心的事情吗?编写器位于 TPL 数据流中,唯一的逻辑是在结构中设置这两个字段。我真的不知道函数范围如何或是否倾向于与缓存回写相关。
想法/建议?
edit:如果我对结构中的变量使用互锁写入怎么办?
edit2:写入量远高于读取量。还有两个单独的并发服务写入Nos & Last字段。因此,它们可以同时编写。这会导致原子性的参考对象方法出现问题。
编辑3:更多细节。假设数组有 30-1000 个元素,每个元素每秒可以更新多次。
由于 Instrument
包含两个双精度值(两个 64 位值),因此无法以原子方式写入它(即使在 64 位计算机上也是如此)。这意味着 Clone
方法如果不执行某种同步,就永远无法创建线程安全的副本。
TLDR;不要使用结构,使用不可变的类。
通过一个小的重新设计,你可能会有更多的运气。尝试使用 .NET 框架中的不可变数据结构和并发集合。例如,将Instrument
设置为不可变类:
// Important: Note that Instrument is now a CLASS!!
public class Instrument
{
public Instrument(double nos, double last)
{
this.NoS = nos;
this.Last = last;
}
// NOTE: Private setters. Class can't be changed
// after initialization.
public double NoS { get; private set; }
public double Last { get; private set; }
}
这样更新Instrument
意味着您必须创建一个新,这使得推理变得更加容易。当您确定只有一个线程在处理单个Instrument
您就完成了,因为工作线程现在可以安全地执行此操作:
Instrument old = a[5];
var newValue = new Instrument(old.NoS + 1, old.Last - 10);
a[5] = newValue;
由于引用类型为 32 位(或 64 位计算机上的 64 位),因此更新引用可确保原子。克隆现在将始终产生正确的副本(它可能缺少后面,但这对您来说似乎不是问题)。
更新
重新阅读您的问题后,我发现我误读了它,因为一个线程不是写入Instrument
,而是写入仪器值,但解决方案实际上是相同的:使用不可变的引用类型。例如,一个简单的技巧是将NoS
和Last
属性的支持字段更改为对象。这使得更新它们是原子的:
// Instrument can be a struct again.
public struct Instrument
{
private object nos;
private object last;
public double NoS
{
get { return (double)(this.nos ?? 0d); }
set { this.nos = value; }
}
public double Last
{
get { return (double)(this.last ?? 0d); }
set { this.last = value; }
}
}
更改其中一个属性时,值将被装箱,并且装箱值是不可变的引用类型。这样,您可以安全地更新这些属性。
以及双精度可以在 32 位上原子写入的知识。
不,这不能保证:
12.5 变量引用的原子性
以下数据类型的读取和写入应为原子:布尔值、字符、字节、字节、短、 ushort、uint、int、float 和引用类型。此外,读取和 写入上一个列表中具有基础类型的枚举类型 也应该是原子的。其他类型的读取和写入,包括长、 ulong、double 和 decimal 以及用户定义的类型不需要 是原子的。
(强调我的)
不保证 32 位甚至 64 位上的双精度。由2个双打组成的strcut
更成问题。你应该重新考虑你的策略。
你可以(ab)使用ReaderWriterLockSlim
。
写作时采取读锁定(因为你说作家之间没有争用)。并在克隆时进行写锁定。
不确定我会这样做,除非真的别无选择。 对于维护此内容的人来说,可能会感到困惑。
数组元素或单个结构字段的读写通常是独立的。 如果当一个线程正在写入特定结构实例的特定字段时,没有其他线程将尝试访问该字段,则结构数组将是隐式线程安全的,除了强制执行上述条件的逻辑之外,不需要任何锁定。
如果一个线程可能会尝试读取double
而另一个线程正在写入它,但两个线程不可能同时尝试写入,则可以采取多种方法来确保读取不会看到部分写入的值。 尚未提及的一种方法是定义一个int64
字段,并使用自定义方法在那里读取和写入double
值(按位转换它们,并根据需要使用Interlocked
)。
另一种方法是为每个数组插槽设置一个 changeCount
变量,该变量递增,因此在写入结构之前,两个 LSB 在任何其他内容之前都是"10",之后Interlocked.Increment
2(请参阅下面的注释)。 在代码读取结构之前,它应该检查写入是否正在进行中。 如果没有,它应该执行读取并确保写入尚未开始或发生(如果在读取开始后发生写入,请循环回开头)。 如果在代码想要读取时正在进行写入,则应获取共享锁,检查写入是否仍在进行中,如果是,则使用联锁操作在锁上设置 changeCount
和 Monitor.Wait
的 LSB。 编写结构的代码应在其Interlocked.Increment
中注意到 LSB 已设置,并且应Pulse
锁。 如果内存模型确保按顺序处理单个线程的读取,并且按顺序处理单个线程的写入,并且一次只有一个线程尝试写入数组插槽,则此方法应将多处理器开销限制为非争用情况下的单个Interlocked
操作。 请注意,在使用此类代码之前,必须仔细研究有关内存模型暗示或不暗示的规则,因为它可能很棘手。
顺便说一句,如果想让每个数组元素成为类类型而不是结构体,还可以采用两种方法:
- 使用
- 不可变的类类型,并在要更新元素时随时使用"Interlocked.CompareExchange"。 要使用的模式是这样的:
我的类老瓦尔,新瓦尔; 做 { oldVal = theArray[下标]; newVal = new MyClass(oldVal.this, oldVal.that+5);或任何变化 } while (Threading.Interlocked.CompareExchange(theArray[subscript], newVal, oldVal) != oldVal);
此方法将始终生成数组元素的逻辑正确的原子更新。 如果在读取数组元素和更新数组元素之间,其他内容更改了值,则"CompareExchange"将使数组元素不受影响,并且代码将循环回去重试。 在没有争用的情况下,此方法效果相当好,尽管每次更新都需要生成一个新的对象实例。 但是,如果许多线程尝试更新相同的数组槽,并且"MyClass"的构造函数需要大量时间来执行,则代码可能会抖动,重复创建新对象,然后发现它们在可以存储时已经过时。 代码总是会向前推进,但不一定很快。 - 使用可变类,并在希望读取或写入类对象时随时锁定它们。 这种方法可以避免在更改某些内容时创建新的类对象实例,但锁定会增加其自身的一些开销。 请注意,读取和写入都必须被锁定,而不可变类方法只需要在写入时使用"互锁"方法。
我倾向于认为结构数组比类对象数组更好的数据持有者,但这两种方法都有优点。
好的,所以在午餐时考虑了一下。
我在这里看到两个,可能是 3 个解决方案。
第一个重要说明:不可变的想法在我的用例中不起作用,因为我有两个服务并行运行到 NoS 和 Last 独立写入。这意味着我需要在这两个服务之间增加一层同步逻辑,以确保当新 ref 由一个服务创建时,另一个服务不会做同样的事情。经典的竞争条件问题,所以绝对不适合这个问题(虽然是的,我可以为每个双打都有一个参考并这样做,但在这一点上它变得荒谬)
解决方案 1整个缓存级别锁定。也许使用旋转锁,只锁定所有更新和快照(使用 memcpy)。这是最简单的,对于我所说的卷来说可能完全没问题。
解决方案 2使所有对双精度的写入都使用互锁写入。当我想拍摄快照时,使用互锁读取来迭代数组和每个值以填充副本。这可能会导致每个结构撕裂,但双精度完好无损,这很好,因为这会不断更新数据,因此最新的概念有点抽象。
解决方案 3不要认为这会起作用,但是对所有双精度进行互锁写入,然后只使用memcopy呢?我不确定我是否会撕裂双打?(请记住,我不在乎结构级别的撕裂)。
如果解决方案 3 有效,那么我想它的最佳性能,但除此之外,我更倾向于解决方案 1。