EmptyCrate Software. Travel. Stuff.

The short answer is because we are updating m_fibonacci_values inside of a mutex locked critical section. Technically speaking volatile alerts the compiler that data may change in "unexpected" ways. Because of the mutex lock, every change to m_fibonacci_values is controlled and it is impossible for one thread to update it while another is trying to read it. As an optimization (and due to the fact that booleans are updated in a single instruction inside the CPU) we are able to update m_running and m_stop_requested without using a mutex, a consequence of that is that we need to mark it as volatile.

So to sum up:

• If the variable you are using is a simple data type (ie int, bool) you do not need a mutex. If you do not use a mutex you must use volatile.
• If the variable is complex (ie std::string, std::vector) you must use a mutex if there is any possibility at all that the variable will be updated while another thread is trying to access it.

I'm sure there is a much deeper explanation of this that is outside of my scope of knowledge.