Interlocked.Increment и return incremented value

Question

У нас есть метод, который поддерживает глобальный индекс последовательности всех событий в нашем приложении. Как и на веб-сайте, ожидается, что такой метод будет безопасным. Поточно-реализация была следующая:

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); 
} 

Однако, я не ясно понять, почему первая реализация не работает. Может ли кто-нибудь помочь мне описать, что происходит в этом случае?

Answer 1

Если она работала так, как в оригинальном примере, вы могли бы сказать, что она будет работать для общего случая

Interlocked.Increment(ref someValue); 

// Any number of operations 

return someValue; 

Для этого, чтобы быть правдой, вы должны устранить все параллелизм (в том числе и параллелизм, реинтерантность, препрессивное выполнение кода ...) между Increment и возвратом. Хуже того, вам нужно убедиться, что даже если someValue используется между возвратом и Increment, это никоим образом не повлияет на возврат. Другими словами - someValue должно быть невозможно изменить (неизменное) между двумя утверждениями.

Вы можете ясно видеть, что если бы это было так, вам не понадобилось бы Interlocked.Increment в первую очередь - вы просто сделали бы someValue++. Вся цель Interlocked и другие атомные операции - обеспечить, чтобы операция выполнялась сразу (атомарно) или вообще отсутствовала. В частности, он защищает вас от любого типа переупорядочения команд (либо путем оптимизации процессора, либо через несколько потоков, выполняемых параллельно на двух логических процессорах, либо предикатов на одном CPU). Но только в рамках атомной операции. Последующее чтение someValue равно , а не часть той же атомной операции (она сама по себе атома, но две атомные операции также не делают сумму атомной).

Но вы не пытаетесь сделать «Любое количество операций», не так ли? На самом деле, ты.Поскольку существуют другие потоки, выполняемые асинхронно по отношению к вашему потоку, ваш поток может быть прерван одним из этих потоков или потоки могут работать параллельно на нескольких логических процессорах.

В реальной среде, ваш пример обеспечивает все большее поле (так является немного лучше, чем someValue++), но это не дает вам уникальные идентификаторы, потому что все, что вы читаете, someValue в некоторый неопределенный момент времени. Если два потока попытаются выполнить приращение в одно и то же время, оба будут успешными (Interlocked.Increment- атомный), но они также будут читать одинаковое значение от someValue.

Это не означает, что вы всегда хотите использовать возвращаемое значение Interlocked.Increment - если вас больше интересует сам приращение, а не добавочное значение. Типичным примером может быть дешевый метод профилирования - каждый вызов метода может увеличивать общее поле, а затем значение считывается раз в то время, например. среднее число вызовов в секунду.

Answer 2

Согласно комментариям, происходит следующее.

Предположим, у нас есть lastUsedIndex == 5 и 2 параллельных резьбы.

Первая нить будет выполнена Interlocked.Increment(ref lastUsedIndex); и lastUsedIndex станет 6. Затем вторая нить выполнит Interlocked.Increment(ref lastUsedIndex);, а lastUsedIndex станет 7.

Тогда оба потока вернут значение lastUsedIndex (помните, что они параллельны). И это значение теперь 7.

Во второй реализации оба потока возвращают результат функции Interlocked.Increment(). Который будет отличаться в каждом потоке (6 и 7). Другими словами, во второй реализации мы возвращаем копию увеличенного значения, и эта копия не затрагивается в других потоках.