Question

I know that in .Net all 32-bit types (e.g, int, bool, etc) are thread safe. That is, there won’t be a partial write (according to the specifications).

But, does the same apply for int? (nullable int)?

Answer 1

The question is poorly worded, and hence the confusion in the answers so far. The question should be “are reads and writes to a variable of type int? guaranteed to be atomic?”

No, absolutely not. The spec is extremely clear on this point:

Reads and writes of the following data types are atomic: bool, char, byte, sbyte, short, ushort, uint, int, float, and reference types. In addition, reads and writes of enum types with an underlying type in the previous list are also atomic. Reads and writes of other types, including long, ulong, double, and decimal, as well as user-defined types, are not guaranteed to be atomic.

It is entirely possible for a thread to read a partially written value from a shared-memory variable of nullable type.

For example, suppose you have an int? variable x which at present has the value null. It therefore contains an int, set to zero, and a bool, set to false. Now on another thread you write the nullable int “5” to x. It is perfectly legal for another thread to read the non-nullable int zero from x, because the “true” in the bool could be set before the 5 is set to the int.