C# 多线程无符号增量

Question

我想从多个线程中增加一个无符号整数。

我知道 Interlocked.Increment，但它不处理无符号整数。我可以使用 lock()，但出于性能原因，我宁愿不使用。

仅以正常方式递增它是线程安全的吗？偶尔的增量是否丢失也没关系，因为它仅用于统计。我不想要的是被破坏的价值。

Answer 1

您说出于性能原因不想使用lock - 但您测试过吗？无争议的锁（听上去很可能是这样）非常便宜。

在线程方面（一般来说，尤其是线程方面），我通常会选择“明显正确”而不是“聪明且性能可能更好”。

对您的应用进行是否有锁定的基准测试，看看您是否能注意到差异。如果锁定产生了显着的不同，那么当然，使用狡猾的东西。否则，我只会坚持使用锁。

您可能想要做的一件事是将Interlocked.Increment 与int 一起使用，并在必要时将其转换为uint，如下所示：

using System;
using System.Reflection;
using System.Threading;

public class Test
{
    private static int count = int.MaxValue-1;

    public static uint IncrementCount()
    {
        int newValue = Interlocked.Increment(ref count);
        return unchecked((uint) newValue);
    }

    public static void Main()
    {
        Console.WriteLine(IncrementCount());
        Console.WriteLine(IncrementCount());
        Console.WriteLine(IncrementCount());
    }

}

输出：

2147483647
2147483648
2147483649

（换句话说，它可以毫无问题地包装。）

Answer 2

如果您确实需要完整范围的无符号整数 (2^32 - 1) 而不是有符号整数 (2^31 -1)，您可以转换为 int64（有一个 Interlocked.Increment 重载需要int64)，然后转换回无符号整数。

Answer 3

在pre-kidney's answer 的基础上，您可以创建自己的助手类。由于增量在二进制级别上的工作方式相同，因此您可以在使用 Unsafe 类进行增量之前将类型从无符号更改为有符号：

using System.Runtime.CompilerServices;
using System.Threading;

public static class InterlockedEx
{
    /// <summary>
    /// unsigned equivalent of <see cref="Interlocked.Increment(ref Int32)"/>
    /// </summary>
    public static uint Increment(ref uint location)
    {
        int incrementedSigned = Interlocked.Increment(ref Unsafe.As<uint, int>(ref location));
        return Unsafe.As<int, uint>(ref incrementedSigned);
    }

    /// <summary>
    /// unsigned equivalent of <see cref="Interlocked.Increment(ref Int64)"/>
    /// </summary>
    public static ulong Increment(ref ulong location)
    {
        long incrementedSigned = Interlocked.Increment(ref Unsafe.As<ulong, long>(ref location));
        return Unsafe.As<long, ulong>(ref incrementedSigned);
    }
}

Answer 4

从 .NET 5.0 开始，Interlocked.Increment 重载无符号和有符号 int32 和 int64。

https://docs.microsoft.com/en-us/dotnet/api/system.threading.interlocked.increment?view=net-5.0

Answer 5

在使用有符号整数的二进制补码表示的系统上（"virtually all"，根据维基百科）递增无符号整数与递增使用相同位集表示的有符号整数具有相同的效果。因此，可以在无符号整数上使用 InterlockedIncrement 而不牺牲任何东西。

例如，对于 3 位，我们有下表：

raw bits | unsigned integer | twos complement signed integer
------------------------------------------------------------
000      |                0 |                             0 
001      |                1 |                             1 
010      |                2 |                             2 
011      |                3 |                             3 
100      |                4 |                            -4 
101      |                5 |                            -3
110      |                6 |                            -2
111      |                7 |                            -1

在这两种情况下，递增一（并考虑溢出）相当于在表中向下移动一个条目。请注意，这不适用于补码算术，因为负数的排列顺序相反。

Answer 6

您可以将 uint 声明为 volatile。

http://msdn.microsoft.com/en-us/library/x13ttww7(VS.71).aspx