Interlocked.Exchange 可空小数

Question

我想交换两个可为空的十进制值，如下所示：

o2 = Interlocked.Exchange(ref o1, o2);

“十进制”类型？必须是引用类型才能将其用作泛型类型或方法“System.Threading.Interlocked.Exchange(ref T, T)”中的参数“T”。

还有比这更好的主意吗：

decimal? temp = o1;
o1 = o2;
o2 = temp;

提前致谢！

Answer 1

两种想法：

• 将其视为 object 并在消费者处
• 创建一个 Box class where T:struct （并使其不可变），并交换一些 Box 引用

在这两种情况下，消费者都应该在执行其他操作之前获取该值的克隆（没有双重读取；它可能在读取之间发生变化） 。

Answer 2

Interlocked.Exchange 尝试在您运行的任何平台上使用 CPU 的原子指令。这些在 CPU 级别是原子的，不需要锁定。这些指令通常仅适用于平台字（通常是 32 或 64 位内存）。

适合单个单词的事物，例如 int、byte 或对堆上 object 的引用都可以进行原子操作。无法容纳在单个单词中的内容，例如像 Nullable 这样的 struct，或者只是一个简单的 decimal ，不能原子交换。

解决方法是交换引用您的十进制（如果它为非空）或仅引用空值（如果它为空）的对象。此对象是使用称为装箱和拆箱的过程自动为您创建的。

public volatile object myNullableDecimal = null;

然后在代码中您可以执行以下操作：

decimal? newValue = 34.3m;
decimal? oldvalue = (decimal?)Interlocked.Exchange(ref myNullableDecimal, newValue);

您必须将 myNullableDecimal 中存储的值显式转换为 decimal? 才能使用它们，因为装箱是自动的，但拆箱不是。

另外，不要在 myNullableDecimal 中放置 int 或除 Nullable 或 decimal 之外的任何内容，因为尽管这些类型可以隐式转换到 Nullable（通过隐式转换为 decimal），装箱 T:struct 可以仅被转换为底层T。

object myObj = 23; // will work but myObj is now a boxed int, not a boxed decimal
var myDecimal = (decimal?) myObj; // throws an exception! Can't convert boxed ints to Nullable<decimal>

由于这些棘手的显式转换，我建议您使用内置转换的方法来包装对“对象”的访问。此方法适用于所有可为空的类型，而不仅仅是小数。如果该位置实际上不包含正确的装箱类型，则会抛出强制转换异常。但请注意：在抛出异常之前它仍然会替换旧值。也就是说，只有按预期工作时，它才是原子的。如果失败，它可能会以非原子方式失败。

public static T? ExchangeNullable<T>(ref object location, T? value) where T:struct
{
    return (T?) Interlocked.Exchange(ref location, value);
}

仅替换可转换为正确返回类型的值的“更安全”方法可能如下所示。此方法是非阻塞的、原子的，并且如果旧值无法转换为适当的类型，则永远不会替换旧值。但此方法很容易出现饥饿问题，因为如果值的更改频率高于验证强制转换是否成功所需的时间，则线程可能永远无法更新该值。为了解决这个问题，该方法采用可选的 CancellationToken 来允许在超时时调用它。避免饥饿问题的唯一方法是使用锁定（实际上是公平锁定，这甚至比常规锁定更昂贵）。

仅当您无法保证对象不会在其中获取除适当值类型的装箱类型之外的其他值时，此方法实际上才有用。如果您在自己的代码中控制对该位置的所有访问，这应该不是问题，但由于编译器允许您在任何对象引用（可能指向任何对象）上调用这些方法），更新可能会失败，并且此方法保证它自动失败。

public static T? ExchangeNullableSafe<T>(ref object location, T? value, CancellationToken token = default(CancellationToken)) where T : struct
{
    // get the expected value
    var expected = location;
    while (true)
    {
        // check if the cast works
        if (expected is T?)
            {
            // cast works, try the update. This includes a memory barrier so we can just do a normal read to
            // populate the expected value initially.
            var actual = Interlocked.CompareExchange(ref location, value, expected);
            // check if the update worked
            if (actual == expected)
            {
                // update worked. Break out of the loop and return 
                break;
            }
            else
            {
                // cast worked but the value was changed before the update occurred.
                // update the expected value to the one the CompareExchange op gave us and try again.
                // again, the memory barrier in the CompareExchange method guarantees that we are updating the expected value each time we run through the loop
                expected = actual;
            }
        }
        else
        {
            // the cast will fail. Just break out of the loop, try the cast, and let it fail.
            break;
        }
        // since this method is vulnerable to starvation, we allow for cancellation between loops.
        token.ThrowIfCancellationRequested();
    }
    // return the value or throw an exception
    return (T?)expected;
}

现在一切都会自动、原子地、无阻塞地转换

object myNullableDecimal = null;

// ...

decimal? oldValue;
oldValue = ExchangeNullable<decimal>(ref myNullableDecimal, m4 + 7); // works and is atomic
// oldValue is an empty Nullable<decimal>, myNullableDecimal is a boxed 13m
oldValue = ExchangeNullable<decimal>(ref myNullableDecimal, 7.4m); // also works 
// oldValue is a Nullable<decimal> with value 13m, myNullableDecimal is a boxed 7.4m
var oldValue = ExchangeNullable<decimal>(ref myNullableDecimal, null); // yep, works too
// oldValue is a Nullable<decimal> with value 7.4m, myNullableDecimal is null