The author also has a rather [confusing article][1] about immutable vs const, that I would discredit personally. He claims that objects accessed via reference to const can modify themselves, which is not true, as you can only access const functions through a const reference.
[1]: http://blog.reliablecpp.com/2013/09/immutable-vs-const/
The example is misleading because there isn't any reason why you would be concerned with such a distinction in this case.
This isn't so much an issue for functions, where the caller is stopped while the callee runs, but it needs to be borne in mind for longer-lived objects that take const references - or, indeed, const pointers - to objects that have longer lifetimes again. (I don't think multithreading need be introduced for this to be an issue.)
There's quite a difference between an object that could change and one that won't, if you're considering caching values across method calls, or setting up the referring object based on the referred object's current state, etc.
You really do not understand what "const" means in C++.
If what you said were true, a whole class of optimizations would be possible that are not currently possible. For example, consider this silly function:
void f(const int *x) {
int y = *x;
g();
if (y == *x) h();
}
int val = 0;
void g() { val = 1; }
int main() { f(&val); }