5

我们有一个方法可以维护应用程序中所有事件的全局序列索引。由于它是网站，因此预计会有这种方法线程安全。线程安全的实现如下：

private static long lastUsedIndex = -1;

public static long GetNextIndex()
{
    Interlocked.Increment(ref lastUsedIndex);
    return lastUsedIndex;
}

但是我们注意到，在一些不重负载下，系统中会出现重复索引。简单的测试表明，对于 100000 次迭代，大约有 1500 个重复项。

internal class Program
{
    private static void Main(string[] args)
    {
        TestInterlockedIncrement.Run();
    }
}

internal class TestInterlockedIncrement
{
    private static long lastUsedIndex = -1;

    public static long GetNextIndex()
    {
        Interlocked.Increment(ref lastUsedIndex);
        return lastUsedIndex;
    }

    public static void Run()
    {
        var indexes = Enumerable
            .Range(0, 100000)
            .AsParallel()
            .WithDegreeOfParallelism(32)
            .WithExecutionMode(ParallelExecutionMode.ForceParallelism)
            .Select(_ => GetNextIndex())
            .ToList();

        Console.WriteLine($"Total values: {indexes.Count}");
        Console.WriteLine($"Duplicate values: {indexes.GroupBy(i => i).Count(g => g.Count() > 1)}");
    }
}

这可以通过以下实现来解决：

public static long GetNextIndex()
{
    return Interlocked.Increment(ref lastUsedIndex);
}

但是，我不清楚，为什么第一次实施没有奏效。任何人都可以帮我描述在这种情况下发生了什么吗？

4

2 回答 2

6

如果它在您的原始示例中起作用，您也可以说它适用于一般情况

Interlocked.Increment(ref someValue);

// Any number of operations

return someValue;

要做到这一点，您必须消除Increment和返回之间的所有并发性（包括并行性、重入性、抢占式代码执行......）。更糟糕的是，您需要确保即使someValue在 return 和 之间使用Increment，它也不会以任何方式影响 return。换句话说 -someValue两个语句之间必须是不可能改变（不可变的）。

您可以清楚地看到，如果是这种情况，您一开始就不需要Interlocked.Increment- 您只需要做someValue++. 和其他原子操作的全部目的Interlocked是确保操作要么立即（原子地）发生，要么根本不发生。特别是，它可以保护您免受任何类型的指令重新排序（通过 CPU 优化或通过在两个逻辑 CPU 上并行运行的多个线程，或在单个 CPU 上被抢占）。但仅限于原子操作之内。随后的读取someValue不是同一个原子操作的一部分（它本身就是原子的，但是两个原子操作也不会使总和成为原子的）。

但是您并没有尝试进行“任意数量的操作”，对吗？事实上，你是。因为有其他线程相对于您的线程异步运行 - 您的线程可能被其中一个线程抢占，或者线程可能真正在多个逻辑 CPU 上并行运行。

在真实环境中，您的示例提供了一个不断增加的字段（因此它比好一点someValue++），但它没有为您提供唯一的 id，因为您正在阅读的所有内容都是someValue在某个不确定的时刻。如果两个线程同时尝试进行增量，两者都会成功（Interlocked.Increment 是原子的），但它们也会从someValue.

这并不意味着您总是想使用Interlocked.Increment- 如果您对增量本身而不是增量值更感兴趣的话。一个典型的例子可能是一种廉价的分析方法——每个方法调用可能会增加一个共享字段，然后每隔一段时间读取一次该值，例如每秒平均调用次数。

于 2017-02-09T13:29:44.740 回答
3

根据评论，正在发生以下情况。

假设我们有lastUsedIndex == 52 个并行线程。

第一个线程将执行Interlocked.Increment(ref lastUsedIndex);并将lastUsedIndex成为6. 然后第二个线程将执行Interlocked.Increment(ref lastUsedIndex);并lastUsedIndex变为7.

然后两个线程都将返回值lastUsedIndex（记住它们是并行的）。而那个值是现在7。

在第二个实现中，两个线程都将返回Interlocked.Increment()函数的结果。6在每个线程（和7）中会有所不同。换句话说，在第二个实现中，我们返回一个递增值的副本，并且该副本在其他线程中不受影响。

于 2017-02-09T13:12:45.457 回答