Question

I have the following situation (caused by a defect in the code):

There’s a shared variable of primitive type (let it be int) that is initialized during program startup from strictly one thread to value N (let it be 0). Then (strictly after the variable is initialized) during the program runtime various threads are started and they in some random order either read that variable or overwrite it with the very same value N (0 in this example). There’s no synchronization around accessing the variable.

Can this situation cause unexpected behavior in the program?

Answer 1

It’s incredibly unlikely but not impossible according to the standard.

There’s nothing stating what the underlying representation of an integer is, not does the standard specify how the values are loaded.

I can envisage, however weird, an implementation where the underlying bit pattern for 0 is 10101010 and the architecture only supports loading data into memory by bit-shifting it over eight cycles but reading it as a single unit in one cycle.

If another thread reads the value while the bit pattern is being shifted in (e.g., 00000001, 00000010,00000101 and so on), you will have a problem.

The chances of anyone designing such a bizarre architecture is so close to zero as to be negligible. But, unfortunately, it’s not zero. All I’m trying to get across is that you shouldn’t rely on assumptions at all when it comes to standards compliance.

And please, before you vote me down, feel free to quote the part of the standard that states this is not possible 🙂