Interlocked.Increment一个整数数组

Question

Is this guaranteed to be threadsafe/not produce unexpected results?

Interlocked.Increment(ref _arr[i]);

My intuition tells me this is not, ie reading the value in _arr[i] is not guaranteed to be 'atomic' with the actual incrementing.

If I am correct in thinking this is wrong, how can I fix this? Thanks.

Answer 1

Assuming nothing changes i or _arr , that should be fine.

An array is regarded as a collection of variables; an interlocked increment should work fine regardless of what is happening to either that element or others in the same array.

Answer 2

If something is asynchronously changing _arr or i then, I'd agree with you, no, the lookup _arr[i] is not necessarily atomic itself.

However, as Jon says, once you have identified an element of (some) _arr , it will be atomically incremented, independent of other actions happening in other elements of the array(s), or to further changes to _arr or i .

If _arr or i are being asynchronously changed, all references to them ( both read and write) need to be inside a lock on a common object. (And then you can reduce the Interlocked.Increment to a simple ++ .