Is it thread safe, with regard to stale cached cpu values, for multiple threads to update List by index without collisions?

Question

Consider the following code:

private static void IncrementList(List<int> items)
{
    Enumerable.Range(0, items.Count).AsParallel().ForAll(i =>
    {
        items[i] += 1;
    });
}

Is this "safe"?

I believe it is safe, because there is no adding or removing which would resize the backing array. However, after learning about the volatile keyword and why it exists, I am wondering if there could be issues with cached cpu values since there is no locking.

var numbers = Enumerable.Range(0, 100).Select(_ => 1).ToList();
IncrementList(numbers);
foreach (var number in numbers) {
    Console.WriteLine(number); // could this write a stale "1" value since IncrementList has no locking?
}

The practical usage for this is I have an API where the request supplies a list of Ids, I need to request the resources for each Id (which I would like to do in parallel because each requires a network request), and I need to return the response in the same order as the requested list of Ids.

Answer 1

Update

On 2nd look your question seems to mostly about // could this write a stale "1" value since IncrementList has no locking?.

The answer is no and all values will be incremented.

Your code has 101 "writes", 1 creation of the list and 100 updates after creation. Let's assume the very unlikely scenario that each of the writes is performed by a new thread. Even in this case there is not logical possibility for a thread to see a stale value.

Please note that in case multiple threads would update the same item[k] locking, not volatile should be used. Answers to volatile for reference type in .net 4.0 are a good read.

---

Old, somewhat still relevant answer.

Your context

It seems that in your example each worker will visit items[i] once - to assign the resource it obtained (or set error, etc.).

Multiple workers (threads) updating a list where each item is only visited once with no locking is safe.

More generally

If different threads are doing incrementing for a given index then it isn't safe.

Here's an example:

var a = new int[]{0,0,0,0,0};

Enumerable.Range(0, 1000).AsParallel().ForAll(i =>
{
    a[i % a.Length] += 1;
});

Console.WriteLine(string.Join(",", a));

The output is:

189,192,188,185,189

One way to address this is to use Interlocked.Increment Method:

Interlocked.Increment(ref a[i % a.Length]);

The output now is:

200,200,200,200,200