问题标签 [interlocked]

我在 Windows 32 位上用 C++ 编写了一个低锁列表。与使用关键部分相比，我得到了很大的改进，但我希望有人能理智地检查我所做的事情是否正确，并且我所做的事情没有任何错误：

如果没有错误（我怀疑；））然后将其视为参考实现：D

编辑：考虑到一些批评，我已经更新了代码。

我正在维护一个可以由多个线程操作的高性能类。许多字段都是易失的整数，事实证明我需要将其中一个升级为双精度值。我很好奇是否有一种无锁的方法可以做到这一点，并且想知道Interlocked.CompareExchange(double, double, double)在 32 位操作系统上宣传的作品是否有问题，或者是否被撕裂。

这段代码是线程安全的吗？或者这样说：

无论如何调用 GetIt() 并且 GetIt() 将返回相同的数字到 2 个不同的线程

似乎有可能，那么我应该使用Interlocked.Read()或将整个东西锁定在一个块中吗？

免责声明：我的帖子显然总是很冗长。如果您碰巧知道标题问题的答案，请随意回答，而无需阅读下面的扩展讨论。

该类System.Threading.Interlocked提供了一些非常有用的方法来帮助编写线程安全代码。更复杂的方法之一是CompareExchange，它可用于计算可能从多个线程更新的运行总数。

由于使用CompareExchange有点棘手，我认为为其提供一些辅助方法是一个相当常识的想法：

现在，也许我只是对普通的快乐感到内疚（我承认，这通常是真的）；但是将上述方法提供的功能限制为仅值对我来说确实很愚蠢double（或者更准确地说，我必须为我想要支持的每种类型编写上述方法的重载版本）。为什么我不能这样做？

我不能这样做，因为Interlocked.CompareExchange<T>显然有一个where T : class约束，我不明白为什么。我的意思是，也许是因为CompareExchange该 accept Int32、Int64、Double等已经有重载；但这似乎不是一个好的理由。例如，在我的情况下，能够使用该Aggregate<T>方法执行广泛的原子计算将非常方便。

我一直在阅读类似问题的答案，但我仍然有点困惑......亚伯有一个很好的答案，但这是我不确定的部分：

...声明一个变量 volatile 使其在每次访问时都是 volatile 的。不可能以任何其他方式强制这种行为，因此 volatile 不能用 Interlocked 代替。这在其他库、接口或硬件可以访问您的变量并随时更新它或需要最新版本的情况下是必需的。

是否Interlocked保证原子操作对所有线程的可见性，还是我仍然必须volatile在值上使用关键字以保证更改的可见性？

这是我的例子：

更新：
我是一项糟糕的运动，我改变了原来的例子，所以又是这样：

I've been doing simple multi-threading in VB.NET for a while, and have just gotten into my first large multi-threaded project. I've always done everything using the Synclock statement because I didn't think there was a better way.

I just learned about the Interlocked Class - it makes it look as though all this:

Can be replaced with a single statement:

This handles all the locking internally and modifies the number. This would be much simpler than writing my own locks for simple operations (longer-running or more complicated operations obviously still need their own locking).

Is there a reason why I'd rolling my own locking, using dedicated locking objects, when I can accomplish the same thing using the Interlocked methods?

我有一个采样系统。我在应用程序中有多个对这些样本感兴趣的客户端线程，但获取样本的实际过程只能在一个上下文中发生。它足够快，可以阻止调用进程直到采样完成，但足够慢，我不希望多个线程堆积请求。我想出了这个设计（精简到最小的细节）：

这在我描述的场景中使用安全吗？

我试图找到一种方法来提供对资源的独占访问，同时提供有关锁状态 (_isWorking) 的信息以供其他类读取。

到目前为止，这是我想出的：

它不能完全像锁一样工作，因为第二个线程在看到一个线程已经在运行该进程时，只会离开该方法并且什么都不做。

这是执行此操作的正确方法，还是有更适合此目的的 C# 3.5 结构？

以及如何实现“真正的”锁定场景，第二个线程在第一个线程完成后仍会执行该方法，同时提供有关状态的信息？

如果我们有：

什么是最好的（如果有的话）调用方式InterlockedExchange，InterlockedIncrement以及其他需要LONG*的联锁功能some_var？

因为，在任何 Windows 上都可以保证LONG32 位，所以通过(long*) some_var. 但是，在我看来，这很丑陋，我无法确认它是安全的。

请注意，我无法将类型更改为，long因为它不可移植。我正好需要 32 位类型。

更新：对提供可移植原子操作的库的一些研究表明，没有人会为转换而烦恼。一些例子：

Apache 便携式运行时 (APR)：

原子操作：

我见过很多好的对象池实现。例如：C# 对象池模式实现。

但似乎线程安全的总是使用锁，从不尝试使用 Interlocked.* 操作。

编写一个不允许将对象返回到池中的方法似乎很容易（只是一个带有 Interlocked.Increments 指针的大数组）。但是我想不出任何方法来编写一个让您返回对象的方法。有人做过吗？