You should absolutely use `volatile' for variables that are updated from the great "elsewhere".
A lot of compiler, at highest optimizations in any event, will still ignore `volatile'. However, the majority of compilers will cache a variable it "knows" isn't updated anyway so `volatile' should only ever help.
It is true, `volatile' may not prevent this issue in all cases, but without `volatile' you can pretty much bank on having such issues.
As for everyone saying different things, I can explain part of that. The `volatile' keyword is generally brought up by people trying to force a sequence point. (An example, as you suggested, would be a portable attempt at critical sections. My favorite example is "double checked locking" without serialization primitives for which `volatile' was once thought to solve.) Only a few compilers honor that ideal. The rest of the uncertainty comes from compilers and the standard both of which are seemingly uncertain.
You aren't trying to introduce a sequence point. You are only saying "Please mister compiler, read this variable every time!".
By the way, this exact example (memory that might be modified by the great "elsewhere") is one of the few cases where `volatile' is useful. It has nothing to do with threads. If your code was using signal handlers capable of interrupting execution in a way that would write to `isRunning_' you would still need (and want) `volatile'.
So, yep, `volatile' is perfectly useless for threading (outside of a few very specific cases for a few compilers); that doesn't have anything to do with you because you are doing it to prevent caching. Your use of threads is irrelevant.
[Edit]
Full disclosure: this is still not going to work the way you are expecting because your reads and writes aren't atomic simply because of `volatile'.
In other words, you need `volatile' for the compiler; you also need a mechanism to guarantee atomicity for the processor.
And some more: if you are using a primitive that is protected from compiler ordering shenanigans by the API level you would not need nor want `volatile'. You would use `volatile' here because you are using a simple integer. If you were using an atomic from a library (like standard POSIX implementations) that atomic would not need `volatile'.
See? There isn't so much a confusing "Some say this; some say that!" situation as there is a confusing reality.
[/Edit]
Soma
