Метод Interlocked.Exchange(Double, Double) не гарантирует одинаковое значение переменной в разных потоках?

int state = 0;
var readerList = new List<int>();
var writerList = new List<int>();
const int LIMIT = 20;
 
Console.WriteLine("Running concurrent writer and reader");
var countdown = new CountdownEvent(2);
RunWriter();
RunReader();
countdown.Wait();
Console.WriteLine("Running completed");
Console.WriteLine($"Lists:\n\t Writer: {string.Join(" ", writerList)}\n\t Reader: {string.Join(" ", readerList)}");
 
void RunWriter() => ThreadPool.QueueUserWorkItem((_) => 
{
    while (state < LIMIT)
    {
        var newValue = Interlocked.Increment(ref state);
        writerList.Add(newValue);
        Console.WriteLine($"{DateTime.Now.TimeOfDay}: Written {newValue}");
    }
    countdown.Signal();
});
 
void RunReader() => ThreadPool.QueueUserWorkItem((_) =>
{
    var counter = 0;
    while (counter < LIMIT)
    {
        var r = Volatile.Read(ref state);
        readerList.Add(r);
        Console.WriteLine($"{DateTime.Now.TimeOfDay}: {r}");
        counter++;
    }
    countdown.Signal();
});

public static Task<Task<T>> [] Interleaved<T>(IEnumerable<Task<T>> tasks)
{
    var inputTasks = tasks.ToList();
 
    var buckets = new TaskCompletionSource<Task<T>>[inputTasks.Count];
    var results = new Task<Task<T>>[buckets.Length];
    for (int i = 0; i < buckets.Length; i++) 
    {
        buckets[i] = new TaskCompletionSource<Task<T>>();
        results[i] = buckets[i].Task;
    }
 
    int nextTaskIndex = -1;
    Action<Task<T>> continuation = completed =>
    {
        var bucket = buckets[Interlocked.Increment(ref nextTaskIndex)];
        bucket.TrySetResult(completed);
    };
 
    foreach (var inputTask in inputTasks)
        inputTask.ContinueWith(continuation, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
 
    return results;
}

{
    List<int> numbers = new List<int>();
    void  AddRange(int beg, int end, int step)
    {
        for (int i = beg; i < end; i+=step)
        {
            numbers.Add(i);
        }
    }
    Task[] tasks = new Task[10];
    for (int i = 0; i < 10; i++)
    {
        int k = i;
        tasks[k] = Task.Run(() => AddRange(k, 10_000, 10));
    }
    Task.WaitAll(tasks);
 
    WriteLine(numbers.Count); // Здесь вывод будет меньше 10_000
}

    void AddRange(int beg, int end, int step)
    {
        for (int i = beg; i < end; i += step)
        {
            lock (numbers)
                numbers.Add(i);
        }
    }

{
    List<int> numbers = new List<int>();
    void AddRange(int beg, int end, int step)
    {
        for (int i = beg; i < end; i += step)
        {
            lock (numbers)
                numbers.Add(i);
 
            // Эмуляция задержки из-за вычислений
            Thread.Sleep(Random.Shared.Next(40));
        }
    }
    Task[] tasks = new Task[10];
    for (int i = 0; i < 10; i++)
    {
        int k = i;
        tasks[k] = Task.Run(() => AddRange(k, 100, 10));
    }
    Task.WaitAll(tasks);
 
    WriteLine(numbers.Count);

{
    List<int> numbers = new List<int>();
    ManualResetEventSlim[] slims = new ManualResetEventSlim[10];
    for (int i = 0; i < 10; i++)
    {
        slims[i] = new ManualResetEventSlim(false);
    }
    slims[9].Set();
    void AddRange(int beg, int end, int step)
    {
        for (int i = beg; i < end; i += step)
        {
            int prev = (beg + 9) % step;
            slims[prev].Wait();
            //lock (numbers)
            //WriteLine($"{beg}-{prev}: {i}");
            numbers.Add(i);
            slims[prev].Reset();
            slims[beg].Set();
 
            // Эмуляция задержки из-за вычислений
            Thread.Sleep(Random.Shared.Next(40));
        }
        slims[beg].Set();
    }
 
    Task[] tasks = new Task[10];
 
    for (int i = 0; i < 10; i++)
    {
        int k = i;
        tasks[k] = Task.Run(() => AddRange(k, 100, 10));
    }
    Task.WaitAll(tasks);
 
    WriteLine(numbers.Count);
}